DEV Community: Adérito Xavier

Elementary Guide to Hashicorp’s Nomad with Linux.

Adérito Xavier — Sat, 13 Jun 2020 10:16:23 +0000

Introduction

In this hands-on guide, I will show you how ridiculously easy it can be to set up a react front-end container and an express back-end container in Nomad and get them to speak with each other as two microservices.

Our orchestration will be composed of 1 group where the 2 containers (front-end and back-end microservices) will live. For simplicity, we will run a single Nomad agent in development mode (development mode is explained below do not panic!!!) and statically map all required ports.

DO NOT DESPAIR

A second guide will be coming soon where I go more in-depth and explain how you can scale your application and let Nomad take care of the port forwarding by itself. Right now I just want you to get an easy grip on Nomad and discover by yourself that it is not as complicated as you think.

The WHY

we went through some changes in how we orchestrate and schedule workloads. Previously, we were using Jenkins and the team was unhappy with its high maintenance, flaky plugins, and inefficient machine usage. So… One day we had a meeting where new technologies are discussed like Docker Swarm and Kubernetes that was when our Senior Tech Lead dropped a bomb on me and brought this idea:

Guys, why not Nomad? It takes the Unix approach of doing one thing and doing it really well, and won’t force a huge change on our infrastructure like Kubernetes would. It’s also made by HashiCorp (who we love).

I was completely terrified when I heard this I said to myself:

WTF is Nomad?! If I stay quiet they will not notice that I have absolutely no idea of what they are talking about.

That same afternoon I googled for Nomad documentation and I got even more terrified. They do have a lot of documentation but very few examples, as a very visual guy I struggled in those cases.

So… I started to break it up into small pieces by finishing Hashicorp’s Nomad tutorial amongst other videos which I will share at the end of this guide. While trying to implement basic orchestrations by myself I slowly started to progress and become confident enough to try more and more ambitious orchestrations, until I got where I am now.

So I decided to help all of you guys who are struggling like I did and give you actual visual examples with multiple basic microservices talking to each other. I hope you enjoy 😃. If I can help one of you it will already be worth it.

Requirements:

Any Linux distro (Ubuntu is preferable) as your OS.
NodeJS and npm installed.
GIT installed.
Docker installed.
NodeJS, Docker, GIT basic knowledge.

What the hell is Nomad anyway?

According to its website Nomad is:

A simple and flexible workload orchestrator to deploy and manage containers and non-containerized applications across on-prem and clouds at scale.

Nomad is a scheduler similar to something like ECS, Kubernetes, Swarm, etc. Your scheduler is going to take information like “I want N copies of image X running” and take care of running and maintaining the availability of these containers on a cluster of different hosts.

If a container crashes, Nomad will detect this and reschedule it. Or say one of your Azure instances crashes and it had 3 different microservices instances running on it. Nomad will reschedule these 3 microservice instances on different machines in your cluster (if capacity is available).

Say you have version A of your app running and you want to deploy version B. If you want to maintain up time you will need either some form of Blue/Green or rolling deployment. Your scheduler defines and executes these types of tasks.

Think of it as a lightweight version of Kubernetes and also much easier to learn.

Nomad architecture

I will try to simplify as much as I can but I strongly advise you to still read this nonetheless https://nomadproject.io/docs/internals/architecture/.

Nomad is composed of two agents: Server and Client.

Server — A Server manages all jobs and clients, runs evaluations and creates task allocations. There is a cluster of servers per region and they manage all jobs and clients, run evaluations, and create task allocations. The servers replicate data between each other and perform leader election to ensure high availability. Servers federate across regions to make Nomad globally aware.
Client — A Client of Nomad is a machine that tasks can be run on. All clients run the Nomad agent. The agent is responsible for registering with the servers, watching for any work to be assigned and executing tasks. The Nomad agent is a long-lived process which interfaces with the servers.

IMPORTANT NOTE: We will be running Nomad in development mode as you will see below, this means that our agent will run as both server and client, data will not be persisted which implicates that every time you close Nomad all the data will be gone.

Single Region Architecture:

Within each region, we have both clients and servers. Servers are responsible for accepting jobs from users, managing clients, and computing task placements. Each region may have clients from multiple datacenters, allowing a small number of servers to handle very large clusters.

In some cases, for either availability or scalability, you may need to run multiple regions. Nomad supports federating multiple regions together into a single cluster. At a high level, this setup looks like this:

Nomad installation

Go to this page.
Check which version of Nomad is suitable for your machine CPU and hit download.
Open your terminal inside the same directory where Nomad was downloaded.

Proceed to unzip the file with the unzip command.

unzip <file>  
# Example: unzip nomad_0.10.2_linux_amd64.zip

Now we just have to move the binary file to our bin.
```
mv nomad /usr/local/bin
```
Check if Nomad is installed by opening another terminal tab or window and running.
```
which nomad
```
Should return something like this:

👏Congratulations you’ve just installed Nomad!

Now we will containerize our front-end and back-end.

For the sake of simplicity, I chose to fork a super simple project made by João Henrique. To check the forked version click here.

It is also documented, if you have time please check out the article he made explaining the project:

How to create a React frontend and a Node/Express backend and connect them
*by João Henrique How to create a React frontend and a Node/Express backend and connect them “two square blue LED…*www.freecodecamp.org

The repository contains:

A front-end built with ReactJS that runs on http://localhost:3000/.
A back-end build with ExpressJS that run on http://localhost:9000/.
Every time the front-end DOM loads it is going to send a GET request to http://localhost:9000/testAPI (our back-end), that GET request will send us a string back with the sentence ‘API is working properly’, which will be displayed on our front-end as well.

I created two docker images to run each of the microservices:

Front-end image link, the Dockerfile for this image is composed of:

FROM node:10

# Create app directory

WORKDIR /usr/src/app

# Install app dependencies

# A wildcard is used to ensure both package.json AND package-lock.json are copied

# where available (npm@5+)

COPY package*.json ./

RUN npm install

# Bundle app source

COPY . .

EXPOSE 3000

CMD [ "npm", "start" ]

Back-end image link, the Dockerfile for this image is (it is a very similar configuration, only the port EXPOSE was changed to 9000)composed of:

FROM node:10

# Create app directory

WORKDIR /usr/src/app

# Install app dependencies

# A wildcard is used to ensure both package.json AND package-lock.json are copied

# where available (npm@5+)

COPY package*.json ./

RUN npm install

# Bundle app source

COPY . .

EXPOSE 9000

CMD [ "npm", "start" ]

For more info on how to run a node application in Docker check this guide, it helped me a lot.

SETUP TIME. YAY!!

Open your terminal and type:
```
nomad agent -dev
```

We are going to run in development mode as I warned you before.

You should see something like this in your terminal:

Open a browser and use the following address http://127.0.0.1:4646/ which will give you a full-on UI where you can see your Jobs.

As obvious as it is in the image above, we added no Jobs yet. To add a Job press on Run Job .

In the Job Definition text area is where we will set all our Job Specifications.

Keep in mind that Job Specifications can also be added through the terminal, but as I iterated before, we are keeping it simple, stupid.

The Job Specifications follow the HCL (HashiCorp Configuration Language) format, it is a configuration language built by HashiCorp. Think of it as a JSON format with a few added abstractions.

OUR JOB SPECIFICATIONS FILE

 # Name of your job
job "my_job" {
    # Which region are you running your job
    datacenters = ["dc1"]

    /*
    Job type can be "service", "batch" or "system".
    A "service" job is made for long lived services that should never go down,
    Service jobs are made to run until explicitly stopped by the operator.
    A "batch" job is made for short lived operations which can last
    from a couple of minutes to a few days.
    Batch schedulers are very similar to Service schedulers but with a few optimizations,
    for the batch workload.
    Batch jobs are intended to run until the job is successful, if the Batch task
    exits with an error it will be handled according to the job's restart 
    and reschedule stanzas.
    A "system" job is made for registering jobs that should be run on every client,
    that has job's constraints.
    The system job is also used when clients join the cluster or transition into the,
    ready state.

    */

    type = "service"
    # Group represents the same of what a pod is in k8s
    group "web" {
        count = 1
        task "frontend" {
            # The driver used to manage the containers
            driver = "docker"
            config {
                # Image we want to pull
                image = "aderito/react-app" 
                # Define the mapped port
                port_map = {
                  frontendPort = 3000
                }
            }
            # Set the computing resources for this task
            resources {
                cpu = 500 # MHz
                memory = 128 # MB
                network {
                    mbits = 10
                    port "frontendPort" {
                        # Set the port that will bridge our orchestration with the container port
                        static = "3000"
                    }
                }
            }

        }
        task "backend" {
            # The driver used to manage the containers
            driver = "docker"

            config {
                # Image we want to pull
                image = "aderito/express-app"
                # Define the mapped port
                port_map = {
                  backendPort = 9000
                }
            }
            # Set the computing resources for this task
            resources {
                cpu = 500 # MHz
                memory = 128 # MB
                network {
                    mbits = 10
                    port "backendPort" {
                      # Set the port that will bridge our orchestration with the container port
                      static = "9000"
                    }
                }
            }

        }

    }
}

Link for the gist here

Let us go through each field:

job "my_job" { 
...
}

Job — It will define the name of your job and inside of it, you will set all the configurations necessary to accomplish your job to run.

datacenters = ["dc1"]
Datacenters — Nomad models infrastructure as regions and datacenters. Regions may contain multiple datacenters. Servers are assigned to a specific region, managing state and making scheduling decisions within that region. In our case, we do not have a real region so we just set it as dc1.

type = "service"
Type — Is the scheduler type that can be used in our job, there are 3 types: service, batch and system.

service job is made for long-lived services that should never go down, Service jobs are made to run until explicitly stopped by the operator. Example: Running a website.

batchjob is made for short-lived operations which can last from a couple of minutes to a few days. Batch schedulers are very similar to Service schedulers but with a few optimizations, for the batch workload. Batch jobs are intended to run until the job is successful, if the Batch task exits with an error it will be handled according to the job’s restart and reschedule stanzas. Example: A web crawler (you probably just want it to run until you got the data you wanted).

system job is made for registering jobs that should be run on every client, that has job constraints. The system job is also used when clients join the cluster or transition into the ready state.

group "web" {
...
}

Group — Defines a series of tasks that should be co-located on the same Nomad Client. Any task within a group will be placed on the same client.

Note: If you worked with Kubernetes before, you can think of a Group the same way as you do with Pod.

count = 1

Count — Specifies the number of task groups that should be running under this group. This value must be non-negative. In a nutshell, if you were to add count = 2 it would spawn two times each task, so 2 frontend tasks and 2 backend tasks.

Warning: Do not try to amplify the count in this project for more than 1, because the ports are statically set(as told in the Introduction), which will create an overlap and trigger an error for port already in use.

task "frontend" {
...
}

Task — Creates an individual unit of work, such as a Docker container, web application, or batch processing.
```
driver = "docker"
```
Driver — Defines the driver used to manage the containers.
```
config {
...
}
```
Config — Specifies the driver configuration, which is passed directly to the driver to start the task.
```
image = "aderito/react-app"
```
Image — Image used for our container.
```
port_map {
...
}
```
Mapped Ports — Some drivers (such as Docker and QEMU) allow you to map ports. A mapped port means that your application can listen on a fixed port (it does not need to read the environment variable) and the dynamic port will be mapped to the port in your container or virtual machine.
```
frontendPort = 3000
```
frontendPort — Is the label we are using to map our container port with our orchestration port.
```
resources {
...
}
```
Resources — Describes the requirements an task needs to execute. Resource requirements include memory, network, CPU, and more.
```
cpu = 500
```
CPU — Defines the processor required specifications in MHz to run this task.
```
memory = 128
```
Memory — Defines the amount of cache memory required in MBs to run this task.
```
network {
...
}
```
Network — Specifies the networking requirements for the task, including the minimum bandwidth and port allocations. When scheduling jobs in Nomad they are provisioned across your fleet of machines along with other jobs and services. Because you don’t know in advance what host your job will be provisioned on, Nomad will provide your tasks with network configuration when they startup.
```
mbits = 10
```
Mbits — Defines the task’s bandwidth for 10mb/s.
```
port "frontendPort" {
...
}
```
Port “frontendPort” — Specifies which port to map according to the label.
```
static = "3000"
```
Static — Describes the port in our orchestration that will speak with the frontend container which is also 3000.

WARNING: I am not going to specify the task for our backend given the outstanding similarities with our frontend task.

MAGIC TIME!

Copy what is inside the gist.
Paste it inside the http://127.0.0.1:4646/ui/jobs/run text area.
You should see a screen like this:

Press Run.
Wait a couple of minutes until the images are completely pulled and the containers are running.
Open http://127.0.0.1:3000/
Voila!!

I will not go much further, for now, I want you to explore Nomad’s UI and get acquainted with it.

Sources that helped me in my struggle:

Introduction to HashiCorp Nomad https://www.youtube.com/watch?v=s_Fm9UtL4YU

From Zero to WOW! with Nomad https://www.youtube.com/watch?v=xl58mjMJjrg — This one helped me the most

Easy and Flexible Application Deployment with HashiCorp Nomad https://www.youtube.com/watch?v=A6CuZUoINX0

Mathematical Notation for Python Developers | Propositional Logic

Adérito Xavier — Thu, 11 Jun 2020 12:10:48 +0000

Introduction

As developers, we require to be always up to date with the new tech stack however we tend to forget the importance of the underlying structure in which new tech stacks are built-in.

I am not saying we are required to be ninjas at assembly or binary but a good understanding of how they work is necessary in order to progress as a developer.

Learning Propositional Logic can help you understand how circuits work programming conditions, writing your code with mathematical notation amongst other things.

Who Is This Article For

By now, you might be wondering: “Do I need to know Python or Binary to understand this article?”. You do not!

I made this article for anyone who is interested in learning mathematical notation.

AND | Conjunction

AND expressions are denoted with the symbol ∧.

a ∧ b = a and b

Both a and b must be true in order for an AND statement to be true or else it will always be false.

|1 ∧ 0 = 0|0 ∧ 1 = 0|1 ∧ 1 = 1 |0 ∧ 0 = 0|


x = (1 and 0)
print(x)
# >> 0
x = (1 and 1)
print(x)
# >> 1
x = (False and True)
print(x)
# >> False
x = (True and True)
print(x)
# >> True

OR | Disjunction

OR expressions are denoted with the symbol ∨.

a ∨ b = a or b

Either a or b must be true in order for an OR statement to be true.

|1 ∨ 0 = 1|0 ∨ 1 = 1|1 ∨ 1 = 1|0 ∨ 0 = 0|


x = (0 or 0)
print(x)
# >> 0
x = (1 or 0)
print(x)
# >> 1
x = (1 or 1)
print(x)
# >> 1
x = (False or False)
print(x)
# >> False
x = (False or True)
print(x)
# >> True
x = (True or True)
print(x)
# >> True

NOT | Negation

NOT expressions are denoted with the symbols ¬ or ~.

If a = 1 then ~a = 0 or vice versa


x = (not False)
print(x)
# >> True
x = (not True)
print(x)
# >> False

Exclusive OR | Exclusive Disjunction | XOR

Exclusive OR expressions are denoted with the symbols ⊕ or ⊻.

The or exclusivity refers to:

a or b but not a and b . They can never be both true at the same time.

|1 ⊻ 0 = 1| 0 ⊻ 1= 1|1 ⊻ 1= 0| 0 ⊻ 0 = 0|

If this leaves you a bit confused try this XOR sandbox http://xor.pw/ you will understand it in no time.


# To define XOR declarions in Python you can simply use the symbol ^
x = (0 ^ 0)
print(x)
# >> 0
x = (1 ^ 1)
print(x)
# >> 0
x = (1 ^ 0)
print(x)
# >> 1

NAND

NAND is a contraction of not and , meaning its result will always be the opposite of its AND expression. NAND is defined with the symbol ↑.

a ↑ b = ~(a ∧ b)

|1 ↑ 0 = 1| 0 ↑ 1= 1|1 ↑ 1= 0| 0 ↑ 0= 1|


x = not(1 and 0)
print(x)
# >> True
x = not(1 and 1)
print(x)
# >> False
x = not(False and True)
print(x)
# >> True
x = not(True and True)
print(x)
# >> False

Implies | Conditional

As the name indicates there is a condition involved. Meaning if “If A then B” or “A implies B”. Implies are denoted with the symbol →.

|0 → 0 = 1| 0 → 1 = 1|1 → 1 = 1|1 → 0 = 0|


def conditional(x, z):
  if x == True:
    return z
  return True

x = True
z = False

print(conditional(x, z))

If and Only If | Biconditional

A biconditional is a connective that represents the condition “if and only if”, by checking is both propositions have the same value. Biconditionals are denoted with the symbol ↔.

A ↔ B = (A → B) ∧ (B → A)

|0 ↔ 0 = 1| 0 ↔ 1 = 0|1 ↔ 1 = 1|1 ↔ 0 = 0|


def main(a, b):

  def conditional(a, b):
    if a == True:
      return b
    return True

  A = conditional(a, b)
  B = conditional(b, a)
  if A == B:
    return True
  else:
    return False

a, b = True, False
print(main(a, b))

a, b = True, True
print(main(a, b))

a, b = False, True
print(main(a, b))

a, b = False, False
print(main(a, b))

Conclusion

Mathematical notation does not have to be complicated as you have seen. Now I leave it up to you as a challenge to try and create your own expressions and test them.

In case you are a Python developer try and create small algorithms using Propositional Logic Notation.

Bibliography

Propositional Logic | Brilliant Math & Science Wiki

Propositional calculus

Mathematical Notation for Python Developers (Part 2) | Set Notation

Adérito Xavier — Thu, 11 Jun 2020 11:46:36 +0000

In the previous article, we went through a basic understanding of what sets are and how their memberships work through simple Python 3 snippets.

In this part 2 we will keep on understanding more about set relationships using our friend Python 3.

Union

As the name denotes, it is a union of 2 or more sets. Unions are denoted with the symbol ∪.

If A and B are sets and A = {1, 2, 3}, B={3, 4, 5} then A ∪ B = {1, 2, 3, 4, 5}


# For more info https://www.w3schools.com/python/ref_set_union.asp

a = {1, 2, 3}
b = {3, 4, 5}

c = a.union(b)
print(c)
# >> {1, 2, 3, 4, 5}

"""
If you do not want to use any in-build functionalities you can simply use the | operator to unite sets.
For more info https://www.programiz.com/python-programming/methods/set/union
"""

c = a | b

print(c)
# >> {1, 2, 3, 4, 5}

Intersection

Intersections are used when you want to obtain the elements that exist in both sets, intersections are denoted with the symbol ∩.

If A and B are sets and A = {1, 2, 3}, B={3, 4, 5} then A ∩ B = {3}


# For more info check
# https://www.w3schools.com/python/ref_set_intersection.asp

a = {1, 2, 3}
b = {3, 4, 5}

c = a.intersection(b)
print(c)
# >> {3}

"""
If you do not want to use any in-build functionalities you can simply use the & operator to get the set intersection.
For more info https://www.programiz.com/python-programming/methods/set/intersection
"""

c = a & b

print(c)
# >> {3}

Difference

The difference is the set of all elements of A that are not elements of B. Difference is denoted with the symbol -.

If A and B are sets and A = {1, 2, 3}, B={3, 4, 5} then A - B = {1, 2}


# For more info check:
# https://www.w3schools.com/python/ref_set_difference.asp

a = {1, 2, 3}
b = {3, 4, 5}

c = a.difference(b)
print(c)
# >>  {1, 2}

"""
If you do not want to use any in-build functionalities you can simply use the - operator to get the difference.
For more info https://www.programiz.com/python-programming/methods/set/difference
"""

c = a - b

print(c)
# >>  {1, 2}

Complement

If A is a set and A = {1, 2, 3} then, the complement of A will refer to the elements, not in A. Complement can be denoted in different ways like A’ or Aᶜ or:

NOTE: In case you are wondering why the last complement notation is in image format, that is because medium does not render some latex configurations correctly.

Let’s assume that set X contains all the possible numbers in the universe and set X= {1 ,2, 3, 4, 5, 6, 7} and we have another set denoted as set A, A = {1, 2, 3} then Aᶜ = {4, 5, 6, 7}.

I am not gonna represent this notation in Python 3 since it is similar to what the difference notation represents.

ALWAYS BE VERY CAREFUL USING THE COMPLEMENT NOTATION AND TRY TO ADD CONTEXT INTO IT OR ELSE YOU MIGHT END UP WITH AN INFINITE SET.

Symmetric Difference

Symmetric Difference is the set that contains elements that exist in A and B but not both. Symmetric Difference is denoted by the symbol ∆.

If A and B are sets and A = {1, 2, 3}, B={3, 4, 5} then A — B = {1, 2, 4, 5}


# For more info check:
# https://www.w3schools.com/python/ref_set_symmetric_difference.asp

a = {1, 2, 3}
b = {3, 4, 5}

c = a.difference(b)
print(c)
# >> {1, 2, 4, 5}

"""
If you do not want to use any in-build functionalities you can simply use the ^ operator to get the difference.
For more info https://www.programiz.com/python-programming/methods/set/symmetric_difference
"""

c = a ^ b

print(c)
# >> {1, 2, 4, 5}

Cartesian Product

Cartesian Product is the multiplication of two sets to form the set of all ordered pairs. Cartesian product is denoted by the multiplication symbol ×.

If A and B are sets and A = {1, 2, 3}, B={4,5,6}

A × B = {(a,b): a ∈ A and b ∈ B}

then A × B = {(2, 4), (3, 4), (1, 5), (1, 4), (2, 6), (3, 6), (1, 6), (2, 5), (3, 5)}


a = {1,2,3}
b = {4,5,6}
v = {(x, y) for x in a for y in b}

print(v)
# >> {(2, 4), (3, 4), (1, 5), (1, 4), (2, 6), (3, 6), (1, 6), (2,5), # (3, 5)}

Power set

If A is a set, then the power set of A is the set of all subsets of A, this includes the empty set and A itself. Power set of A is denoted by P(A).

A = {1, 2, 3} then P(A) = {{},{1},{2},{3},{1,2},{1,3},{2,3},{1,2,3}}

NOTE:

In the Python snippet below you will notice that we are not using sets within sets. This happens because every object you add inside of a set must be immutable. So you will see the parent set and instead of child sets you will see itertools objects with the powerset iterations.

WELL, WHY IN THE HELL DO THEY TO BE IMMUTABLE YOU MIGHT ASK?

Because every object you add inside of a set is gonna be hashed, that is the way sets in Python to figure out the unique values and index them, meaning you cannot add sets, lists, dictionaries or any other mutable object within a set.

Hashable:
An object is hashable if it has a hash value which never changes during its lifetime (it needs a hash() method), and can be compared to other objects (it needs an eq() or cmp() method).
Hashable objects which compare equal must have the same hash value. Hashability makes an object usable as a dictionary key and a set member, because these data structures use the hash value internally.
All of Python’s immutable built-in objects are hashable, while no mutable containers (such as lists or dictionaries) are. Objects which are instances of user-defined classes are hashable by default; they all compare unequal, and their hash value is their id().


from itertools import combinations, chain

# Defines the parent set and adds an empty tuple inside (this is our # equivalent to an empty set)
empty_set = {(), }

def powerset(someset):

  try:

    # Check if someset is a set

    someset.isdisjoint

  except AttributeError:

    raise TypeError(

      f"{powerset.__name__} accepts only a set-like object as       parameter"

    ) from None

  # Get the length/cardinality of the set. 

  size = len(someset) # Check below for more information on length.

  combs =  set()

  for k in range(1, size+1):
    """

    Combinations are emitted in lexicographic sorted order. So,if the input iterable is sorted, the combination tuples will be produced in sorted order.

    For more info check:  https://docs.python.org/3/library/itertools.html#itertools.combinations

    """

    subset = combinations(someset, k)

    combs.add(subset)

  """

  Make an iterator that returns elements from the first iterable  until it is exhausted, then proceeds to the next iterable, until all of the iterables are exhausted. Used for treating consecutive sequences as a single sequence.

  For more info check: https://docs.python.org/3/library/itertools.html#itertools.chain

  """

  return set(chain(empty_set, *combs))

print(powerset({1, 2, 3}))
# >> {(1, 3), (2,), (1, 2), (1, 2, 3), (2, 3), (1,), (), (3,)}

Cardinality

Cardinality represents the number of elements within a set also known as set length. If A is a set then the cardinality of A is denoted by |A|.

If A is a set and A = {1, 2, 3} then |A| = 3


a = {1, 2, 3}
cardinality = len(a)
print(cardinality)
# >> 3

Helpful Links:

https://www.rapidtables.com/math/symbols/BasicMathSymbols.html

Mathematical Notation for Python Developers (Part 1)

Adérito Xavier — Wed, 10 Jun 2020 11:58:58 +0000

Introduction

As a self-taught developer, I struggled most of the time reading whitepapers, or going through data science courses that contain incredible amounts of mathematical jargon (mostly weird and magic symbols).

This tutorial is going to be focused on translating mathematical notation to Python.

NOTE: Python 3.6 is what I will be using throughout this tutorial series.

FYI: I will avoid using any libraries whenever I can so that anyone can easily understand what is going on underneath the notation.

My thanks to Edward R. Scheinerman for the book Mathematical Notation: A Guide for Engineers and Scientists which was my biggest help at the start.

If you are struggling as I did I strongly advice you to buy it, here is a link if you feel inclined to https://www.amazon.co.uk/Mathematical-Notation-Engineers-Scientists-Scheinerman/dp/B00E321MU8.

SO… LET’S GET STARTED SHALL WE?

SETS

A set is a collection of items where repetition is forbidden.

Example: {1, 2, 3, 4}

Reinforced note: A set with repetition like {1,2,3,4,4} will be equal to {1,2,3,4} again, because repetition is non-existent within a set.

Set declaration in Python:

# Declare the set
my_set = {1, 2, 3, 4, 4}
# Will output {1, 2, 3, 4}

# FUN NOTE: Strings can also be added to sets in Python like        
# {"Banana", "Apple"}

Set and element membership

Memberships between Sets and elements are defined with the following symbols:

For easy readability, I will add the symbol followed by it’s meaning.

∈ (element exists in), 1 ∈ {1, 2, 3}

∋ (set contains element), {1, 2, 3} ∋ 1

# Declare the set
my_set = {1, 2, 3}

print(1 in my_set) # Equivalent to 1 ∈ {1, 2, 3} or {1, 2, 3} ∋ 1
>> True

∉ (element does not exist in), 1 ∉ {2, 5, 6}

∌ (set does not contain element), {2, 5, 6} ∌ 1

# Declare the set
my_set = {1, 2, 3}

(1 not in my_set) # Equivalent to 1 ∉ {2, 5, 6} or {2, 5, 6} ∌ 1
>> True

Dealing with large Sets

Let’s say you want to create a set that goes from 1 to 100, you do not want to write everything on paper, instead, you can show some of the elements that convey the pattern and fills the rest with ellipses (…).

Example: {1, 2, 3, 4, 5, …, 100}

You can also take the following approach:

{x ∈ ℤ: 1 ≤ x ≤ 100}

NOTES:

ℤ = {-∞, …, -2,-1,0,1,2….∞} = the set of all integers.
x represents a dummy variable used for each iteration.

x ∈ ℤ = x iteration is part of the ℤ set, in other words, x is gonna be an integer in each iteration.

1 ≤ x ≤ 100 = Each x iteration is going to be (greater or equal to 1) and (less or equal to 100).

# In case you are wondering about why the range goes to 101, that is 
# because, the last argument is where it stops, meaning it will only 
# reach the previous iteration (100).
# For more information check:   
# https://www.geeksforgeeks.org/python-range-function/

our_set = {x for x in range(1, 101)}
print(our_set)
>> {1, 2, 3, 4,..., 100}

# or the easiest approach for newcomers.

our_set = set()
for x in range(1, 101):    
    our_set.add(x)
print(our_set)
>> {1, 2, 3, 4,..., 100}

Set to Set Membership

Set Equality

A = {1, 2, 3, 4, 5} and B = {1, 2, 3, 4, 5} then we can say that **A = B **because the elements found in both variables are the same.

Subsets

A = {1, 2, 3} and B = {1, 2, 3, 4, 5}

We can see that every element in A can be found in B as well, meaning A is a subset of B or A ⊆ B = {1, 2, 3} ⊆ {1, 2, 3, 4, 5}

⊆ equivalent to“subset of”.

# For more info check:
# https://www.programiz.com/python-programming/methods/set/issubset
A = {1, 2, 3}
B = {1, 2, 3, 4, 5}
C = {1, 2, 4, 5}

# Returns True
print(A.issubset(B))

# Returns False
# B is not subset of A
print(B.issubset(A))

# Returns False
print(A.issubset(C))

# Returns True
print(C.issubset(B))

Supersets

A superset is taken by the opposite order of a subset, since here we are defining that set A has *all *the elements of | is a superset of **B in which we could also say that B is a subset of A.

A ⊇ B = B ⊆ A

A = {1, 2, 3, 4, 5} and B = {1, 2, 3}

A ⊇ B = {1, 2, 3, 4, 5} ⊆ {1, 2, 3}

⊇ equivalent to “superset of”.

"""
For more information check:
https://www.programiz.com/python-programming/methods/set/issuperset
"""

A = {1, 2, 3, 4, 5}
B = {1, 2, 3}
C = {1, 2, 3}

# Returns True
print(A.issuperset(B))

# Returns False
print(B.issuperset(A))

# Returns True
print(C.issuperset(B))

DEV Community: Adérito Xavier

Elementary Guide to Hashicorp’s Nomad with Linux.

Introduction

DO NOT DESPAIR

The WHY

Requirements:

What the hell is Nomad anyway?

Nomad architecture

Single Region Architecture:

Nomad installation

👏Congratulations you’ve just installed Nomad!

SETUP TIME. YAY!!

OUR JOB SPECIFICATIONS FILE

Let us go through each field:

WARNING: I am not going to specify the task for our backend given the outstanding similarities with our frontend task.

MAGIC TIME!

Sources that helped me in my struggle:

Mathematical Notation for Python Developers | Propositional Logic

Introduction

Who Is This Article For

AND | Conjunction

OR | Disjunction

NOT | Negation

Exclusive OR | Exclusive Disjunction | XOR

NAND

Implies | Conditional

If and Only If | Biconditional

Conclusion

Bibliography

Other Links on mathematical notation with Python

Mathematical Notation for Python Developers (Part 2) | Set Notation

Union

Intersection

Difference

Complement

ALWAYS BE VERY CAREFUL USING THE COMPLEMENT NOTATION AND TRY TO ADD CONTEXT INTO IT OR ELSE YOU MIGHT END UP WITH AN INFINITE SET.

Symmetric Difference

Cartesian Product

Power set

NOTE:

WELL, WHY IN THE HELL DO THEY TO BE IMMUTABLE YOU MIGHT ASK?

Cardinality

Helpful Links:

Mathematical Notation for Python Developers (Part 1)

Introduction

SO… LET’S GET STARTED SHALL WE?

SETS

Set declaration in Python:

Set and element membership

Dealing with large Sets

Set to Set Membership

Set Equality

Subsets

Supersets