<h2 id="introduction">Introduction</h2>
JavaScript is single-threaded, which means that everything, including events, runs on the same thread. If the thread is not free, code execution is delayed until it is. This can be a bottleneck for our application since it can really cause serious performance problems.
There are different ways by which we can overcome this limitation. In this article, we'll explore the modern way to handle asynchronous tasks in JavaScript - <code>Promise</code>s.
<h2 id="callbacksandcallbackhell">Callbacks and Callback Hell</h2>
If you are a JavaScript developer, you've likely heard of, if not used, callbacks:
<pre><code class="hljs">function hello() {
 console.log(&#x27;Hello World!&#x27;);
}

setTimeout(hello, 5000);
</code></pre>
This code executes a function, <code>setTimeout()</code>, that waits for the defined time (in milliseconds), passed to it as the second argument, <code>5000</code>. After the time passes, only then does it execute the function <code>hello</code>, passed to it as the first parameter.
The function is an example of a higher-order function and the function passed to it is called a callback - a function that is to be executed after another function has finished executing.
Let's say that we sent a request to an API to return the most-liked photos from our account. We may likely have to wait for the response as the API/service may be doing some calculations before returning the response.
This can potentially take a long time, and we do not want to freeze the thread while we wait for the response. Instead, we'll create a callback that will be notified when the response comes in.
Until that time, the rest of the code is being executed, like presenting posts and notifications.
If you've ever worked with callbacks, there's a chance you've experienced <a target="_blank" href="/avoiding-callback-hell-in-node-js/">callback hell</a>:
<pre><code class="hljs">doSomething(function(x) {
 console.log(x);
 doSomethingMore(x, function(y) {
 console.log(y);
 doRestOfTheThings(y, function(z) {
 console.log(z);
 });
 });
});
</code></pre>
Imagine a case where we request the server to get multiple resources - a person, their friends and their friend's posts, the comments for each friends' posts, the replies, etc.
Managing these nested dependencies can quickly get out of hand.
We can avoid callback hells and handle asynchronous calls by using <code>Promise</code>s.
<h2 id="creatingapromise">Creating a Promise</h2>
<code>Promise</code>s, as the name implies, is the function &quot;giving its word&quot; that a value will be returned at a later time. It's a proxy for a value that might not be returned, if the function we expect a response from doesn't deliver.
Instead of returning concrete values, these asynchronous functions return a <code>Promise</code> object, which will at some point either be fulfilled or not.
Most often, when coding, we'll be consuming <code>Promise</code>s rather than creating them. It is the libraries/frameworks that create <code>Promise</code>s for the clients to consume.
Still, it is good to understand what goes behind creating a <code>Promise</code>:
<pre><code class="hljs">let promise = new Promise(function(resolve, reject) {
 // Some imaginary 2000 ms timeout simulating a db call
 setTimeout(()=&gt; {
 if (/* if promise can be fulfilled */) {
 resolve({msg: &#x27;It works&#x27;, data: &#x27;some data&#x27;});
 } else {
 // If promise can not be fulfilled due to some errors like network failure
 reject(new Error({msg: &#x27;It does not work&#x27;}));
 }
 }, 2000);
});
</code></pre>
The promise constructor receives an argument - a callback. The callback can be a regular function or an arrow function. The callback takes two parameters - <code>resolve</code> and <code>reject</code>. Both are function references. The callback is also called the executor.
The executor runs immediately when a promise is created. The promise is resolved by calling <code>resolve()</code> if the promise is fulfilled, and rejected by calling <code>reject()</code> if it can't be fulfilled.
Both <code>resolve()</code> and <code>reject()</code> take one argument - <code>boolean</code>, <code>string</code>, <code>number</code>, <code>array</code>, or an <code>object</code>.
<h2 id="consumingapromise">Consuming a Promise</h2>
Through an API, say we requested some data from the server and it's uncertain when it'll be returned - if it'll be returned at all. This is a perfect example of when we'd use a <code>Promise</code> to help us out.
Assuming that the server's method that handles our call returns a <code>Promise</code>, we can consume it:
<pre><code class="hljs">promise.then((result) =&gt; {
 console.log(&quot;Success&quot;, result);
}).catch((error) =&gt; {
 console.log(&quot;Error&quot;, error);
})
</code></pre>
As we can see we have chained two methods - <code>then()</code> and <code>catch()</code>. These are a few of the various methods provided by the <code>Promise</code> object.
<code>then()</code> is executed when things go well, i.e the promise is fulfilled by the <code>resolve()</code> method. And if the promise was rejected, the <code>catch()</code> method will be called with the error sent to <code>reject</code>.
<h2 id="chainingpromises">Chaining Promises</h2>
If we have a sequence of asynchronous tasks one after another that need to be performed - the more nesting there is, the more confusing the code becomes.
This leads us to callback hell, which can easily be avoided by chaining several <code>then()</code> methods on a single <code>Promise</code>d result:
<pre><code class="hljs">promise.then(function(result) {
 // Register user
 return {account: &#x27;blahblahblah&#x27;};
}).then(function(result) {
 // Auto login
 return {session: &#x27;sjhgssgsg16775vhg765&#x27;};
}).then(function(result) {
 // Present WhatsNew and some options
 return {whatsnew: {}, options: {}};
}).then(function(result) {
 // Remember the user Choices
 return {msg: &#x27;All done&#x27;};
});
</code></pre>
As we can see the result is passed through the chain of <code>then()</code> handlers:
<ul>
<li>The initial <code>promise</code> object resolves</li>
<li>Then the <code>then()</code> handler is called to register user</li>
<li>The value that it returns is passed to the next <code>then()</code> handler to auto login the user</li>
<li>...and so on</li>
</ul>
Also, the <code>then(handler)</code> may create and return a promise.
Note: Although technically we can do something like the proceeding example, it can take away from the point of chaining. Although this technique can be good for when you need to optionally call asynchronous methods:
<pre><code class="hljs">let promise = new Promise(function(resolve, reject) {
 setTimeout(() =&gt; resolve({msg: &#x27;To do some more job&#x27;}), 1000);
});

promise.then(function(result) {
 return {data: &#x27;some data&#x27;};
});

promise.then(function(result) {
 return {data: &#x27;some other data&#x27;};
});

promise.then(function(result) {
 return {data: &#x27;some more data&#x27;};
});
</code></pre>
What we are doing here is just adding several handlers to one promise, all of which process the <code>result</code> independently. They are not passing the result to each other in the sequence.
This way, all handlers get the same result – the result of that promise - <code>{msg: 'To do some more job'}</code>.
<h2 id="conclusion">Conclusion</h2>
<code>Promise</code>s, as the name implies, is the function &quot;giving its word&quot; that a value will be returned at a later point in time. It's a proxy for a value that might not be returned, if the function we expect a response from doesn't deliver.
Instead of returning concrete values, these asynchronous functions return a <code>Promise</code> object, which will at some point either be fulfilled or not.
If you have worked with callbacks, you must appreciate the clean and clear semantics of <code>Promise</code>s.
As a Node/JavaScript developer, we'll be dealing with promises more often. After all, it is an asynchronous world, full of surprises.

Shadab Ansari

A Promise is an asynchronous function "giving its word" that a value will be returned at a later time. Introduced in ES6/ES2015, Promises provide a modern alternative to callbacks

Promises in Node.js

<h2 id="introduction">Introduction</h2>
Nowadays, most programs are written in a high-level language such as C, Java, or Python. These languages are designed more for people, rather than machines, by hiding some hardware details of a specific computer from the programmer.
Simply put, high-level languages simplify the job of telling a computer what to do. However, since computers only understand instructions in machine code (in the form of 1's and 0's), we can not properly communicate with them without some sort of a translator.
This is why language processors exist.
The language processor is a special translator system used to turn a program written in a high-level language, which we call &quot;source code&quot;, into machine code, which we call &quot;object program&quot; or &quot;object code&quot;.
In order to design a language processor, a very precise description of lexicon and syntax, as well as semantics of a high-level language, is needed.
There are three types of language processors:
<ul>
<li>Assembler</li>
<li>Interpreter</li>
<li>Compiler</li>
</ul>
In the next few sections we'll go over each of these types of processors and discuss their purpose, differences, etc.
<h2 id="assemblylanguagesandtheassembler">Assembly Languages and the Assembler</h2>
Most assembly languages are very similar to machine code (which is why they are specific to a computer architecture or operating system), but instead of using binary numbers in order to describe an instruction, it uses mnemonic symbols.
Each mnemonic symbol represents an operation code or instruction, and we typically need several of them in conjunction to do anything useful. These instructions can be used to move values between registers (in Intel86-64 architecture this command would be <code>MOV</code>), to do basic arithmetic operations on values such as addition, subtraction, multiplication, and division(ADD, SUB, MUL, DIV), as well as the basic logical operations like shifting a number left or right or negation (<code>SHL</code>, <code>SHR</code>, <code>NEG</code>). It can also use unconditional and conditional jumps, which is useful in order to implement a &quot;for&quot; loop, &quot;while&quot; loop, or an &quot;if&quot; statement (<code>JMP</code>, <code>JE</code>, <code>JLE</code>...).
For example, if the processor interprets the binary command <code>10110</code> as &quot;move from one register into another register&quot;, an assembly language would replace it with a command, such as <code>MOV</code>.
Each register also has a binary identifier, such as <code>000</code>. This can also be replaced with a more &quot;human-like&quot; name, such as <code>EAX</code>, which is one of the general registers in x86.
If we, say, wanted to move a value into a register, the machine code would look something like:
<pre><code class="hljs">00001 000 00001010
</code></pre>
<ul>
<li>00001: Is the move command</li>
<li>000: Is the register's identifier</li>
<li>00001010: Is the value we want to move</li>
</ul>
In an assembly language, this can be written as something like:
<pre><code class="hljs">MOV EAX, A
</code></pre>
<ul>
<li><code>MOV</code> is the move command</li>
<li><code>EAX</code> is the register's identifier</li>
<li><code>A</code> is the hexadecimal value we want to move (10 in decimal)</li>
</ul>
If we wanted to write down a simple expression <code>EAX = 7 + 4 - 2</code> in machine code, it would look something like this:
<pre><code class="hljs">00001 000 00000111
00001 001 00000100
00010 000 001
00001 001 00000010
00011 000 001
</code></pre>
<ul>
<li>00001 is the &quot;move&quot; command</li>
<li>00010 is the &quot;addition&quot; command</li>
<li>00011 is the &quot;subtraction&quot; command</li>
<li>000, 001 are the registers' identifiers</li>
<li>00000111, 00000100, 00000010 are the integer values we are using in this expressions</li>
</ul>
In assembly, this bunch of binary numbers would be written as:
<pre><code class="hljs">MOV EAX, 7
MOV R8, 4
ADD EAX, R8
MOV R9, 2
SUB EAX, R9
</code></pre>
<ul>
<li><code>MOV</code> is the move command</li>
<li><code>ADD</code> is the addition command</li>
<li><code>SUB</code> is the subtraction command</li>
<li><code>EAX</code>, <code>R8</code>, <code>R9</code> are the registers' identifiers</li>
<li>7, 4, 2: are the integer values we are using in this expressions</li>
</ul>
Although still not as readable as a high-level language, it's still a lot more humanly readable than the binary command. The hardware components of the CPU and registers are by far more abstract.
This makes it easier for a programmer to write source code, not needing to manipulate numbers in order to program. Translation to object code in machine language is simple and straightforward, done by an assembler.
Since the source code is already pretty similar to machine code, there's no need to compile or interpret the code - it's assembled as is.
<h2 id="interpretedlanguagesandtheinterpreter">Interpreted Languages and the Interpreter</h2>
Every program has a translating phase, and an execution phase. In interpreted languages, these two phases are intertwined - instructions written in a high-level programming language are directly executed without being previously converted to object code or machine code.
Both of the phases are done by an interpreter - a language processor that translates a single statement (line of code), executes it immediately and then moves on to the next line. If faced with an error, an interpreter terminates the translating process at that line and displays an error. It cannot move on to the next line and execute it unless the previous error is removed.
Interpreters have been used since 1952, and their job was to ease programming within limitations of computers at the time (for example, there was significantly less storage space in the first generation of computers than there is now). The first high-level interpreted language was Lisp, first implemented in 1958 on an IBM704 computer.
The most common interpreted programming languages nowadays are Python, Perl, and Ruby.
<h2 id="compiledlanguagesandthecompiler">Compiled Languages and the Compiler</h2>
Unlike in interpreted programming languages, the translating phase and the execution phase in compiled programming languages are completely separated, and the translation is done by a compiler.
The compiler is a language processor that reads the complete source code written in a high-level language and translates it into an equivalent object code as a whole. Typically, this object code is stored in a file. If there are any errors in the source code, the compiler specifies them at the end of compilation, along with the lines in which the errors were found. After their removal, the source code can be recompiled.
Low-level languages are usually compiled because, being directly translated into machine code, they allow the programmer much more control over hardware components like memory or CPU.
The first high-level compiled programming language was FORTRAN, made in 1957 by a team led by John Backus at IBM.
The most common compiled languages nowadays are C++, Rust, and Haskell.
<h2 id="bytecodelanguages">Bytecode Languages</h2>
Bytecode languages, also called &quot;portable code&quot; or &quot;p-code&quot; languages are the type of programming languages that fall under categories of both interpreted and compiled languages since they make use of both compilation and interpretation when translating and executing the code.
Bytecode is, simply put, a program code that has been compiled from source code into low-level code designed for a software interpreter. After the compilation (from source code to bytecode), it can be compiled further into machine code, which is recognized by the CPU, or it can be executed by a virtual machine, which then acts as the interpreter.
The bytecode is universal and can be transferred in the compiled state to other devices (with all of the advantages of compiled code). The CPU then converts it into the specific machine code for the device. That being said, you can compile the source code once and run it everywhere - granted the device has another layer, which is used to convert the bytecode into machine code.
The most well-known virtual machine for bytecode interpretation is the Java Virtual Machine (JVM), which is so common that several languages have implementations built to run on it.
<img src="https://stackabuse.s3.amazonaws.com/media/programming-language-processors-1.png" alt="">
Credit: <a rel="nofollow" target="_blank" href="https://www.viralpatel.net/java-virtual-machine-an-inside-story/">ViralPatel</a>
When the program is first run in a bytecode language, there is a delay while the code compiles into bytecode, but the execution speed is significantly increased compared to standard interpretative languages (since the source code is optimized for the interpreter).
One of the biggest advantages of bytecode languages is its platform independence, which used to be typical only for interpreted languages, while the programs are much faster than regular interpreted languages when it comes to execution.
Another thing worthy of mention here is just-in-time (JIT) compilation. As opposed to ahead-of-time (AOT) compilation, the code is being compiled as it's running. This essentially improves the compilation speed and utilizes the performance benefits of compilation with the flexibility of interpretation.
Then again, dynamic compilation doesn't always have to be better/faster than static compilation - it mostly depends on which kind of project you're working on.
The flagship languages that are compiled into bytecode are Java and C# and with them are languages such as Clojure, Groovy, Kotlin, and Scala.
<h2 id="advantagesanddisadvantagescompiledvsinterpreted">Advantages and Disadvantages: Compiled vs Interpreted</h2>
<h3 id="performance">Performance</h3>
Since a compiler translates an entire source code of a programming language into executable machine code for CPU, it takes a large amount of time to analyze the source code, but once the analysis and compilation are finished, the overall execution is much faster.
On the other hand, the interpreter translates the source code line by line, each one being executed as it gets translated, which leads to faster analysis of the source code, but the execution is significantly slower.
<h3 id="debugging">Debugging</h3>
The debugging is much easier when it comes to interpreted programming languages because the code is being translated until the error is met, so we know exactly where it is, and it is easier to fix.
Contrarily, debugging in a compiled language is much more tedious. If a program is written in a compiled language, it has to be manually compiled, which is an additional step in order to run a program. This may not seem like an issue - and it isn't with small programs.
Please keep in mind that massive projects can take tens of minutes and some even hours to compile.
Moreover, the compiler generates the error message after it has scanned the source code as a whole, so the error could be anywhere in the program. Even if the line of an error is specified, after changing the source code and fixing it, we need to recompile it and only then can the improved version be executed. This may not seem like an issue - and it isn't with small programs.
Please keep in mind that massive projects can take tens of minutes and some even hours to compile. Fortunately, many errors can be noticed before compilation with the help of IDEs, but not all of them.
<h3 id="sourcecodevsobjectcode">Source Code vs Object Code</h3>
For interpreted programming languages, the source code is necessary for the execution. This means that the source code of the application is exposed to the user - like JavaScript is exposed in the browser.
Allowing users to fully read the source code may allow malicious users to manipulate and find loopholes in the logic. This can, to an extent, be limited using code obfuscation, but it's still a lot more easily accessible than compiled code.
On the other hand, once the program written in a compiled programming language is compiled into object code, it can be executed an infinite number of times, and the source code is not needed anymore.
This is why, when passing the program to a user, it is enough to just send them the object code, and not the source code, usually in the form of an <code>.exe</code> file on Windows.
Interpreted code is more susceptible to code injection attacks and the fact that they're not type-checked introduces us to a whole new set of programming exceptions and errors.
<h2 id="conclusion">Conclusion</h2>
There is no &quot;better&quot; way of translating source code, and both compiled and interpreted programming languages have their advantages and disadvantages, as mentioned above.
In a lot of cases, the line between &quot;compiled&quot; and &quot;interpreted&quot; isn't clearly defined when it comes to more modern programming language, really, there's nothing stopping you from writing a compiler for an interpreted language, for an example.

Mila Lukic

The language processor is turns a program written in a high-level language into machine code.

Programming Language Processors

The <a rel="nofollow" target="_blank" href="https://numpy.org/">Numpy</a> library can be used to perform a variety of mathematical/scientific operations such as matrix cross and dot products, finding sine and cosine values, <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Fourier_transform">Fourier transform</a> and shape manipulation, etc. The word Numpy is short-hand notation for &quot;Numerical Python&quot;.
In this article, you will see how to solve a system of linear equations using Python's Numpy library.
<h2 id="whatisasystemoflinearequations">What is a System of Linear Equations?</h2>
Wikipedia defines a <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/System_of_linear_equations">system of linear equations</a> as:
<blockquote>
<blockquote>
In mathematics, a system of linear equations (or linear system) is a collection of two or more linear equations involving the same set of variables.
</blockquote>
</blockquote>
The ultimate goal of solving a system of linear equations is to find the values of the unknown variables. Here is an example of a system of linear equations with two unknown variables, <code>x</code> and <code>y</code>:
Equation 1:
<pre><code class="hljs">4x + 3y = 20
-5x + 9y = 26
</code></pre>
To solve the above system of linear equations, we need to find the values of the <code>x</code> and <code>y</code> variables. There are multiple ways to solve such a system, such as Elimination of Variables, Cramer's Rule, Row Reduction Technique, and the Matrix Solution. In this article we will cover the matrix solution.
In the matrix solution, the system of linear equations to be solved is represented in the form of matrix <code>AX = B</code>. For instance, we can represent Equation 1 in the form of a matrix as follows:
<pre><code class="hljs">A = [[ 4 3]
 [-5 9]]

X = [[x]
 [y]]

B = [[20]
 [26]]
</code></pre>
To find the value of <code>x</code> and <code>y</code> variables in Equation 1, we need to find the values in the matrix <code>X</code>. To do so, we can take the dot product of the inverse of matrix <code>A</code>, and the matrix <code>B</code> as shown below:
<pre><code class="hljs">X = inverse(A).B
</code></pre>
If you are not familiar with how to find the inverse of a matrix, take a look at this link to understand how to manually <a rel="nofollow" target="_blank" href="https://www.mathsisfun.com/algebra/matrix-inverse.html">find the inverse</a> of a matrix. To understand the matrix dot product, check out <a rel="nofollow" target="_blank" href="https://www.mathsisfun.com/algebra/matrix-multiplying.html">this article</a>.
<h2 id="solvingasystemoflinearequationswithnumpy">Solving a System of Linear Equations with Numpy</h2>
From the previous section, we know that to solve a system of linear equations, we need to perform two operations: matrix inversion and a matrix dot product. The Numpy library from Python supports both the operations. If you have not already installed the Numpy library, you can do with the following <code>pip</code> command:
<pre><code class="hljs">$ pip install numpy
</code></pre>
Let's now see how to solve a system of linear equations with the Numpy library.
<h3 id="usingtheinvanddotmethods">Using the inv() and dot() Methods</h3>
First, we will find inverse of matrix <code>A</code> that we defined in the previous section.
Let's first create the matrix <code>A</code> in Python. To create a matrix, the <code>array</code> method of the Numpy module can be used. A matrix can be considered as a list of lists where each list represents a row.
In the following script we create a list named <code>m_list</code>, which further contains two lists: <code>[4,3]</code> and <code>[-5,9]</code>. These lists are the two rows in the matrix <code>A</code>. To create the matrix <code>A</code> with Numpy, the <code>m_list</code> is passed to the <code>array</code> method as shown below:
<pre><code class="hljs">import numpy as np

m_list = [[4, 3], [-5, 9]]
A = np.array(m_list)
</code></pre>
To find the inverse of a matrix, the matrix is passed to the <code>linalg.inv()</code> method of the Numpy module:
<pre><code class="hljs">inv_A = np.linalg.inv(A)

print(inv_A)
</code></pre>
The next step is to find the dot product between the inverse of matrix <code>A</code>, and the matrix <code>B</code>. It is important to mention that matrix dot product is only possible between the matrices if the inner dimensions of the matrices are equal i.e. the number of columns of the left matrix must match the number of rows in the right matrix.
To find the dot product with the Numpy library, the <code>linalg.dot()</code> function is used. The following script finds the dot product between the inverse of matrix <code>A</code> and the matrix <code>B</code>, which is the solution of the Equation 1.
<pre><code class="hljs">B = np.array([20, 26])
X = np.linalg.inv(A).dot(B)

print(X)
</code></pre>
Output:
<pre><code class="hljs">[2. 4.]
</code></pre>
Here, <code>2</code> and <code>4</code> are the respective values for the unknowns <code>x</code> and <code>y</code> in Equation 1. To verify, if you plug <code>2</code> in place of the unknown <code>x</code> and <code>4</code> in the place of the unknown <code>y</code> in equation <code>4x + 3y</code>, you will see that the result will be 20.
Let's now solve a system of three linear equations, as shown below:
<pre><code class="hljs">4x + 3y + 2z = 25
-2x + 2y + 3z = -10
3x -5y + 2z = -4
</code></pre>
The above equation can be solved using the Numpy library as follows:
Equation 2:
<pre><code class="hljs">A = np.array([[4, 3, 2], [-2, 2, 3], [3, -5, 2]])
B = np.array([25, -10, -4])
X = np.linalg.inv(A).dot(B)

print(X)
</code></pre>
In the script above the <code>linalg.inv()</code> and the <code>linalg.dot()</code> methods are chained together. The variable <code>X</code> contains the solution for Equation 2, and is printed as follows:
<pre><code class="hljs">[ 5. 3. -2.]
</code></pre>
The value for the unknowns <code>x</code>, <code>y</code>, and <code>z</code> are 5, 3, and -2, respectively. You can plug these values in Equation 2 and verify their correctness.
<h3 id="usingthesolvemethod">Using the solve() Method</h3>
In the previous two examples, we used <code>linalg.inv()</code> and <code>linalg.dot()</code> methods to find the solution of system of equations. However, the Numpy library contains the <code>linalg.solve()</code> method, which can be used to directly find the solution of a system of linear equations:
<pre><code class="hljs">A = np.array([[4, 3, 2], [-2, 2, 3], [3, -5, 2]])
B = np.array([25, -10, -4])
X2 = np.linalg.solve(A,B)

print(X2)
</code></pre>
Output:
<pre><code class="hljs">[ 5. 3. -2.]
</code></pre>
You can see that the output is same as before.
<h3 id="arealworldexample">A Real-World Example</h3>
Let's see how a system of linear equation can be used to solve real-world problems.
Suppose, a fruit-seller sold 20 mangoes and 10 oranges in one day for a total of $350. The next day he sold 17 mangoes and 22 oranges for $500. If the prices of the fruits remained unchanged on both the days, what was the price of one mango and one orange?
This problem can be easily solved with a system of two linear equations.
Let's say the price of one mango is <code>x</code> and the price of one orange is <code>y</code>. The above problem can be converted like this:
<pre><code class="hljs">20x + 10y = 350
17x + 22y = 500
</code></pre>
The solution for the above system of equations is shown here:
<pre><code class="hljs">A = np.array([[20, 10], [17, 22]])
B = np.array([350, 500])
X = np.linalg.solve(A,B)

print(X)
</code></pre>
And here is the output:
<pre><code class="hljs">[10. 15.]
</code></pre>
The output shows that the price of one mango is $10 and the price of one orange is $15.
<h2 id="conclusion">Conclusion</h2>
The article explains how to solve a system of linear equations using Python's Numpy library. You can either use <code>linalg.inv()</code> and <code>linalg.dot()</code> methods in chain to solve a system of linear equations, or you can simply use the <code>solve()</code> method. The <code>solve()</code> method is the preferred way.

Guest Contributor

Two or more linear equations with the same set of variables are called a system of linear equations. We can solves for those variables in Python with Numpy.

Solving Systems of Linear Equations with Python's Numpy

<h2 id="introduction">Introduction</h2>
One of the key driving factors to technology growth is data. Data has become more important and crucial in the tools being built as technology advances. It has become the driving factor to technology growth, how to collect, store, secure, and distribute data.
This data growth has led to an increase in the utilization of cloud architecture to store and manage data while minimizing the hassle required to maintain consistency and accuracy. As consumers of technology, we are generating and consuming data and this has necessitated the requirement of elaborate systems to help us manage the data.
The cloud architecture gives us the ability to upload and download files from multiple devices as long as we are connected to the Internet. And that is part of what AWS helps us achieve through S3 buckets.
<h2 id="whatiss3">What is S3?</h2>
<a rel="nofollow" target="_blank" href="https://aws.amazon.com/s3/">Amazon Simple Storage Service</a> (S3) is an offering by Amazon Web Services (AWS) that allows users to store data in the form of objects. It is designed to cater to all kinds of users, from enterprises to small organizations or personal projects.
S3 can be used to store data ranging from images, video, and audio all the way up to backups, or website static data, among others.
An S3 bucket is a named storage resource used to store data on AWS. It is akin to a folder that is used to store data on AWS. Buckets have unique names and based on the tier and pricing, users receive different levels of redundancy and accessibility at different prices.
Access privileges to S3 Buckets can also be specified through the AWS Console, the AWS CLI tool, or through provided APIs and libraries.
<h2 id="whatisboto3">What is Boto3?</h2>
<a rel="nofollow" target="_blank" href="https://boto3.amazonaws.com/v1/documentation/api/latest/index.html">Boto3</a> is a software development kit (SDK) provided by AWS to facilitate the interaction with S3 APIs and other services such as <a rel="nofollow" target="_blank" href="https://aws.amazon.com/ec2/">Elastic Compute Cloud</a> (EC2). Using Boto3, we can list all the S3 buckets, create EC2 instances, or control any number of AWS resources.
<h2 id="whyuses3">Why use S3?</h2>
We can always provision our own servers to store our data and make it accessible from a range of devices over the Internet, so why should we use AWS's S3? There are several scenarios where it comes in handy.
First, AWS S3 eliminates all the work and costs involved in building and maintaining servers that store our data. We do not have to worry about acquiring the hardware to host our data or the personnel required to maintain the infrastructure. Instead, we can focus solely on our code and ensuring our services are in the best condition.
By using S3, we get to tap into the impressive performance, availability, and scalability capabilities of AWS. Our code will be able to scale effectively and perform under heavy loads and be highly available to our end users. We get to achieve this without having to build or manage the infrastructure behind it.
AWS offers tools to help us with analytics and audit, as well as management and reports on our data. We can view and analyze how the data in our buckets is accessed or even replicate the data into other regions to enhance the access of the data by the end-users. Our data is also encrypted and securely stored so that it is secure at all times.
Through <a target="_blank" href="/serverless-python-application-development-with-aws-chalice/">AWS Lambda</a> we can also respond to data being uploaded or downloaded from our S3 buckets and respond to users through configured alerts or reports for a more personalized and instant experience as expected from technology.
<h2 id="settingupaws">Setting Up AWS</h2>
To get started with S3, we need to set up an account on <a rel="nofollow" target="_blank" href="https://aws.amazon.com/">AWS</a> or log in to an existing one.
We will also need to set up the AWS CLI tool to be able to interact with our resources from the command line, which is available for Mac, Linux, and Windows.
We can install it by running:
<pre><code class="hljs">$ pip install awscli
</code></pre>
Once the CLI tool is set up, we can generate our credentials under our profile dropdown and use them to configure our CLI tool as follows:
<pre><code class="hljs">$ aws configure
</code></pre>
This command will give us prompts to provide our <code>Access Key ID</code>, <code>Secret Access Key</code>, default regions, and output formats. More details about configuring the AWS CLI tool can be found <a rel="nofollow" target="_blank" href="https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html">here</a>.
<h2 id="ourapplicationflaskdrive">Our Application - FlaskDrive</h2>
<h3 id="setup">Setup</h3>
Let's build a Flask application that allows users to upload and download files to and from our S3 buckets, as hosted on AWS.
We will use the Boto3 SDK to facilitate these operations and build out a simple front-end to allow users to upload and view the files as hosted online.
It is advisable to use a virtual environment when working on Python projects, and for this one we will use the <a rel="nofollow" target="_blank" href="https://pipenv.readthedocs.io/en/latest/#install-pipenv-today">Pipenv</a> tool to create and manage our environment. Once set up, we create and activate our environment with Python3 as follows:
<pre><code class="hljs">$ pipenv install --three
$ pipenv shell
</code></pre>
We now need to install <code>Boto3</code> and <code>Flask</code> that are required to build our FlaskDrive application as follows:
<pre><code class="hljs">$ pipenv install flask
$ pipenv install boto3
</code></pre>
<h3 id="implementation">Implementation</h3>
After setting up, we need to create the buckets to store our data and we can achieve that by heading over to the AWS console and choosing S3 in the Services menu.
After creating a bucket, we can use the CLI tool to view the buckets we have available:
<pre><code class="hljs">$ aws s3api list-buckets
{
 &quot;Owner&quot;: {
 &quot;DisplayName&quot;: &quot;robley&quot;,
 &quot;ID&quot;: &quot;##########################################&quot;
 },
 &quot;Buckets&quot;: [
 {
 &quot;CreationDate&quot;: &quot;2019-09-25T10:33:40.000Z&quot;,
 &quot;Name&quot;: &quot;flaskdrive&quot;
 }
 ]
}
</code></pre>
We will now create the functions to upload, download, and list files on our S3 buckets using the Boto3 SDK, starting off with the <code>upload_file</code> function:
<pre><code class="hljs">def upload_file(file_name, bucket):
 &quot;&quot;&quot;
 Function to upload a file to an S3 bucket
 &quot;&quot;&quot;
 object_name = file_name
 s3_client = boto3.client(&#x27;s3&#x27;)
 response = s3_client.upload_file(file_name, bucket, object_name)

 return response
</code></pre>
The <code>upload_file</code> function takes in a file and the bucket name and uploads the given file to our S3 bucket on AWS.
<pre><code class="hljs">def download_file(file_name, bucket):
 &quot;&quot;&quot;
 Function to download a given file from an S3 bucket
 &quot;&quot;&quot;
 s3 = boto3.resource(&#x27;s3&#x27;)
 output = f&quot;downloads/{file_name}&quot;
 s3.Bucket(bucket).download_file(file_name, output)

 return output
</code></pre>
The <code>download_file</code> function takes in a file name and a bucket and downloads it to a folder that we specify.
<pre><code class="hljs">def list_files(bucket):
 &quot;&quot;&quot;
 Function to list files in a given S3 bucket
 &quot;&quot;&quot;
 s3 = boto3.client(&#x27;s3&#x27;)
 contents = []
 for item in s3.list_objects(Bucket=bucket)[&#x27;Contents&#x27;]:
 contents.append(item)

 return contents
</code></pre>
The function <code>list_files</code> is used to retrieve the files in our S3 bucket and list their names. We will use these names to <a target="_blank" href="https://stackabuse.com/download-files-with-python/">download the files</a> from our S3 buckets.
With our S3 interaction file in place, we can build our Flask application to provide the web-based interface for interaction. The application will be a simple single-file Flask application for demonstration purposes with the following structure:
<pre><code class="hljs">.
├── Pipfile # stores our application requirements
├── __init__.py
├── app.py # our main Flask application
├── downloads # folder to store our downloaded files
├── s3_demo.py # S3 interaction code
├── templates
│ └── storage.html
└── uploads # folder to store the uploaded files
</code></pre>
The core functionality of our Flask application will reside in the <code>app.py</code> file:
<pre><code class="hljs">import os
from flask import Flask, render_template, request, redirect, send_file
from s3_demo import list_files, download_file, upload_file

app = Flask(__name__)
UPLOAD_FOLDER = &quot;uploads&quot;
BUCKET = &quot;flaskdrive&quot;

@app.route(&#x27;/&#x27;)
def entry_point():
 return &#x27;Hello World!&#x27;

@app.route(&quot;/storage&quot;)
def storage():
 contents = list_files(&quot;flaskdrive&quot;)
 return render_template(&#x27;storage.html&#x27;, contents=contents)

@app.route(&quot;/upload&quot;, methods=[&#x27;POST&#x27;])
def upload():
 if request.method == &quot;POST&quot;:
 f = request.files[&#x27;file&#x27;]
 f.save(os.path.join(UPLOAD_FOLDER, f.filename))
 upload_file(f&quot;uploads/{f.filename}&quot;, BUCKET)

 return redirect(&quot;/storage&quot;)

@app.route(&quot;/download/&lt;filename&gt;&quot;, methods=[&#x27;GET&#x27;])
def download(filename):
 if request.method == &#x27;GET&#x27;:
 output = download_file(filename, BUCKET)

 return send_file(output, as_attachment=True)

if __name__ == &#x27;__main__&#x27;:
 app.run(debug=True)
</code></pre>
This is a simple Flask application with 4 endpoints:
<ul>
<li>The <code>/storage</code> endpoint will be the landing page where we will display the current files in our S3 bucket for download, and also an input for users to upload a file to our S3 bucket,</li>
<li>The <code>/upload</code> endpoint will be used to receive a file and then call the <code>upload_file()</code> method that uploads a file to an S3 bucket</li>
<li>The <code>/download</code> endpoint will receive a file name and use the <code>download_file()</code> method to download the file to the user's device</li>
</ul>
And finally, our HTML template will be as simple as:
<pre><code class="hljs">&lt;!DOCTYPE html&gt;
&lt;html&gt;
 &lt;head&gt;
 &lt;title&gt;FlaskDrive&lt;/title&gt;
 &lt;/head&gt;
 &lt;body&gt;
 &lt;div class=&quot;content&quot;&gt;
 &lt;h3&gt;Flask Drive: S3 Flask Demo&lt;/h3&gt;
 &lt;p&gt;Welcome to this AWS S3 Demo&lt;/p&gt;
 &lt;div&gt;
 &lt;h3&gt;Upload your file here:&lt;/h3&gt;
 &lt;form method=&quot;POST&quot; action=&quot;/upload&quot; enctype=multipart/form-data&gt;
 &lt;input type=file name=file&gt;
 &lt;input type=submit value=Upload&gt;
 &lt;/form&gt;
 &lt;/div&gt;
 &lt;div&gt;
 &lt;h3&gt;These are your uploaded files:&lt;/h3&gt;
 &lt;p&gt;Click on the filename to download it.&lt;/p&gt;
 &lt;ul&gt;
 {% for item in contents %}
 &lt;li&gt;
 &lt;a href=&quot;/download/{{ item.Key }}&quot;&gt; {{ item.Key }} &lt;/a&gt;
 &lt;/li&gt;
 {% endfor %}
 &lt;/ul&gt;
 &lt;/div&gt;
 &lt;/div&gt;
 &lt;/body&gt;
&lt;/html&gt;
</code></pre>
With our code and folders set up, we start our application with:
<pre><code class="hljs">$ python app.py
</code></pre>
When we navigate to <code>http://localhost:5000/storage</code> we are welcomed by the following landing page:
<img src="https://stackabuse.s3.amazonaws.com/media/uploading-and-downloading-files-with-s3-and-boto-in-python-1.png" alt="flask_drive_landing_1">
Let us now upload a file using the input field and this is the output:
<img src="https://stackabuse.s3.amazonaws.com/media/uploading-and-downloading-files-with-s3-and-boto-in-python-2.png" alt="flask_drive_landing_2">
We can confirm the upload by checking our S3 dashboard, and we can find our image there:
<img src="https://stackabuse.s3.amazonaws.com/media/uploading-and-downloading-files-with-s3-and-boto-in-python-3.png" alt="flask_drive_s3_dashboard">
Our file has been successfully uploaded from our machine to AWS's S3 Storage.
On our FlaskDrive landing page, we can download the file by simply clicking on the file name then we get the prompt to save the file on our machines.
<h2 id="conclusion">Conclusion</h2>
In this post, we have created a Flask application that stores files on AWS's S3 and allows us to download the same files from our application. We used the Boto3 library alongside the AWS CLI tool to handle the interaction between our application and AWS.
We have eliminated the need for us having our own servers to handle the storage of our files and tapped into Amazon's infrastructure to handle it for us through the AWS Simple Storage Service. It has taken us a short time to develop, deploy and make our application available to end-users and we can now enhance it to add permissions among other features.
The source code for this project is available <a rel="nofollow" target="_blank" href="https://github.com/ro6ley/flask-drive"> here on GitHub</a>.

Robley Gori

AWS S3 is a service that allows us to easily manage file storage in the cloud. In this article, we'll manage file uploads with Python and Flask

File Management with AWS S3, Python, and Flask

<h2 id="introduction">Introduction</h2>
Much of the software and web apps we build today requires some kind of hosting for files - images, invoices, audio files, etc. The traditional way to store files was just to just save them on the server's HDD. However, saving files onto the HDD of the server comes with limitations such as not being able to scale up, being required to allocate space before using and much higher/non-flexible prices. Not to mention, requesting a huge amount of (potentially large) images can really put a strain on the server.
To offload the servers, developers started hosting files with cloud storage providers such as <a rel="nofollow" target="_blank" href="https://aws.amazon.com/s3/">AWS S3</a>, <a rel="nofollow" target="_blank" href="https://cloud.google.com/storage/">Google Cloud Storage</a>, etc.
In this article we will show you how to write Node.js code to upload files to S3.
<h2 id="whatiss3">What is S3?</h2>
S3, or Simple Storage Service, is a cloud storage service provided by Amazon Web Services (AWS). Using S3, you can host any number of files while paying for only what you use.
S3 also provides multi-regional hosting to customers by their region and thus are able to really quickly serve the requested files with minimum delay.
<h2 id="settinguptheenvironment">Setting up the Environment</h2>
<h3 id="awscredentials">AWS Credentials</h3>
To get started, you need to generate the AWS Security Key Access Credentials first. To do so, login to your AWS Management Console.
Click on your username:
<img src="https://stackabuse.s3.amazonaws.com/media/uploading-files-to-s3-with-nodejs-1.png" alt="">
Then select Access Keys -&gt; Create New Access Key:
<img src="https://stackabuse.s3.amazonaws.com/media/uploading-files-to-s3-with-nodejs-2.png" alt="">
After that you can either copy the Access Key ID and Secret Access Key from this window or you can download it as a <code>.CSV</code> file:
<img src="https://stackabuse.s3.amazonaws.com/media/uploading-files-to-s3-with-nodejs-3.png" alt="">
<h3 id="creatingans3bucket">Creating an S3 Bucket</h3>
Now let's create an AWS S3 Bucket with proper access. We can do this using the AWS management console or by using Node.js.
To create an S3 bucket using the management console, go to the S3 service by selecting it from the service menu:
<img src="https://stackabuse.s3.amazonaws.com/media/uploading-files-to-s3-with-nodejs-4.png" alt="">
Select &quot;Create Bucket&quot; and enter the name of your bucket and the region that you want to host your bucket. If you already know from which region the majority of your users will come from, it's wise to select a region as close to theirs as possible. This will ensure that the files from the server will be served in a more optimal time-frame.
The name you select for your bucket should be a unique name among all AWS users, so try a new one if the name is not available:
<img src="https://stackabuse.s3.amazonaws.com/media/uploading-files-to-s3-with-nodejs-5.png" alt="">
Follow through the wizard and configure permissions and other settings per your requirements.
To create the bucket using Node.js, we'll first have to set up our development environment.
<h3 id="developmentenvironment">Development Environment</h3>
So now let's get started with our example by configuring a new Node.js project:
<pre><code class="hljs">$ npm init
</code></pre>
To start using any AWS Cloud Services in Node.js, we have to install the AWS SDK (System Development Kit).
Install it using your preferred package manager - we'll use <code>npm</code>:
<pre><code class="hljs">$ npm i --save aws-sdk
</code></pre>
<h2 id="implementation">Implementation</h2>
<h3 id="creatingans3bucket">Creating an S3 Bucket</h3>
If you have already created a bucket manually, you may skip this part. But if not, let's create a file, say, <code>create-bucket.js</code> in your project directory.
Import the <code>aws-sdk</code> library to access your S3 bucket:
<pre><code class="hljs">const AWS = require(&#x27;aws-sdk&#x27;);
</code></pre>
Now, let's define three constants to store <code>ID</code>, <code>SECRET</code>, and <code>BUCKET_NAME</code>. These are used to identify and access our bucket:
<pre><code class="hljs">// Enter copied or downloaded access ID and secret key here
const ID = &#x27;&#x27;;
const SECRET = &#x27;&#x27;;

// The name of the bucket that you have created
const BUCKET_NAME = &#x27;test-bucket&#x27;;
</code></pre>
Now, we need to initialize the S3 interface by passing our access keys:
<pre><code class="hljs">const s3 = new AWS.S3({
 accessKeyId: ID,
 secretAccessKey: SECRET
});
</code></pre>
With the S3 interface successfully initialized, we can go ahead and create the bucket:
<pre><code class="hljs">const params = {
 Bucket: BUCKET_NAME,
 CreateBucketConfiguration: {
 // Set your region here
 LocationConstraint: &quot;eu-west-1&quot;
 }
};

s3.createBucket(params, function(err, data) {
 if (err) console.log(err, err.stack);
 else console.log(&#x27;Bucket Created Successfully&#x27;, data.Location);
});
</code></pre>
At this point we can run the code and test if the bucket is created on the cloud:
<pre><code class="hljs">$ node create-bucket.js
</code></pre>
If the code execution is successful you should see the success message, followed by the bucket address in the output:
<pre><code class="hljs">Bucket Created Successfully http://test-bucket-2415soig.s3.amazonaws.com/
</code></pre>
You can visit your S3 dashboard and make sure the bucket is created:
<img src="https://stackabuse.s3.amazonaws.com/media/uploading-files-to-s3-with-nodejs-7.png" alt="">
To see a complete list of regions and other parameters, please take a look at the <a rel="nofollow" target="_blank" href="https://docs.aws.amazon.com/AmazonS3/latest/dev/Introduction.html">official documentation</a>.
<h3 id="uploadingfiles">Uploading Files</h3>
At this point, let's implement the file upload functionality. In a new file, e.g. <code>upload.js</code>, import the <code>aws-sdk</code> library to access your S3 bucket and the <code>fs</code> module to read files from your computer:
<pre><code class="hljs">const fs = require(&#x27;fs&#x27;);
const AWS = require(&#x27;aws-sdk&#x27;);
</code></pre>
We need to define three constants to store <code>ID</code>, <code>SECRET</code>, and <code>BUCKET_NAME</code> and initialize the S3 client as we did before.
Now, let's create a function that accepts a <code>fileName</code> parameter, representing the file we want to upload:
<pre><code class="hljs">const uploadFile = (fileName) =&gt; {
 // Read content from the file
 const fileContent = fs.readFileSync(fileName);

 // Setting up S3 upload parameters
 const params = {
 Bucket: BUCKET_NAME,
 Key: &#x27;cat.jpg&#x27;, // File name you want to save as in S3
 Body: fileContent
 };

 // Uploading files to the bucket
 s3.upload(params, function(err, data) {
 if (err) {
 throw err;
 }
 console.log(`File uploaded successfully. ${data.Location}`);
 });
};
</code></pre>
Before we upload the file, we need to read its contents as a buffer. After reading it, we can define the needed parameters for the file upload, such as <code>Bucket</code>, <code>Key</code>, and <code>Body</code>.
Besides these three parameters, there's a long list of other optional parameters. To get an idea of the things you can define for a file while uploading, here are a few useful ones:
<ul>
<li><code>StorageClass</code>: Define the class you want to store the object. S3 is intended to provide fast file serving. But in case files are not accessed frequently you can use a different storage class. For example, if you have files which are hardly touched you can store them in &quot;S3 Glacier Storage&quot; where the price is very low compared to &quot;S3 Standard Storage&quot;. But it will take more time to access those files in case you need it and is covered with a different service level agreement.</li>
<li><code>ContentType</code>: Sets the image MIME type. The default type will be &quot;binary/octet-stream&quot;. Adding a MIME type like &quot;image/jpeg&quot; will help browsers and other HTTP clients to identify the type of the file.</li>
<li><code>ContentLength</code>: Sets the size of the body in bytes, which comes in handy if body size cannot be determined automatically.</li>
<li><code>ContentLanguage</code>: Set this parameter to define which language the content is in. This will also help HTTP clients to identify or translate the content.</li>
</ul>
For the <code>Bucket</code> parameter, we'll use our bucket name, whereas for the <code>Key</code> parameter we'll add the file name we want to save as, and for the <code>Body</code> parameter, we'll use <code>fileContent</code>.
With that done, we can upload any file by passing the file name to the function:
<pre><code class="hljs">uploadFile(&#x27;cat.jpg&#x27;);
</code></pre>
You can replace <code>cat.jpg</code> with a file name that exists in the same directory as the code, a relative file path, or an absolute file path.
At this point, we can run the code and test out if it works:
<pre><code class="hljs">$ node upload.js
</code></pre>
If everything is fine, you should see output like what is shown below with a link to your file, which is stored in <code>data.Location</code>:
<pre><code class="hljs">File uploaded successfully. https://test-bucket-1242tsr.s3.ap-northeast-2.amazonaws.com/cat.jpg
</code></pre>
If there is any error it should be displayed on the console as well.
Additionally, you can go to your bucket in the AWS Management Console and make sure the file is uploaded.
<img src="https://stackabuse.s3.amazonaws.com/media/uploading-files-to-s3-with-nodejs-6.png" alt="">
<h2 id="conclusion">Conclusion</h2>
To offload our application servers, a popular choice of developers is to host files using storage providers such as AWS S3, Google Cloud Storage, etc. We've made a very simple Node.js app that handles file uploads to S3 using its interface via the <code>aws-sdk</code> module.
Depending on your requirements you can also configure public access to your bucket or the files using the console.
If you'd like to play around with the code, as always, you can find it on GitHub in <a rel="nofollow" target="_blank" href="https://gist.github.com/jkasun/b0e2b818e0271db9c1363f637dacf12e">this Gist</a>.

Janith Kasun

Uploading Files to AWS S3 with Node.js

Usman Malik

Text generation is one of the state-of-the-art applications of NLP. In this article, you will see how to generate text via deep learning techniques in Python using the Keras library.

Python for NLP: Deep Learning Text Generation with Keras

Dan Nelson

Analyzing API Data with MongoDB, Seaborn, and Matplotlib

Olivera Popović

Graphs in Java: Dijkstra's Algorithm

<h2 id="introduction">Introduction</h2>
Graphs are a convenient way to store certain types of data. The concept was ported from mathematics and appropriated for the needs of computer science.
Due to the fact that many things can be represented as graphs, graph traversal has become a common task, especially used in data science and machine learning.
<ul>
<li><a target="_blank" href="/graph-theory-and-graph-related-algorithms-theory-and-implementation">Graph Theory and Graph-Related Algorithm's Theory and Implementation</a>
<ul>
<li><a target="_blank" href="/graphs-in-java-representing-graphs-in-code/">Representing Graphs in Code</a></li>
<li><a target="_blank" href="/graphs-in-java-depth-first-search-dfs/">Depth-First Search (DFS)</a></li>
<li>Breadth-First Search (BFS)</li>
<li><a target="_blank" href="/graphs-in-java-dijkstras-algorithm/">Dijkstra's Algorithm</a></li>
<li><a target="_blank" href="/graphs-in-java-minimum-spanning-trees-prims-algorithm">Minimum Spanning Trees - Prim's Algorithm</a></li>
</ul>
</li>
</ul>
<h2 id="breadthfirstsearch">Breadth-First Search</h2>
Breadth First Search (BFS) visits &quot;layer-by-layer&quot;. This means that in a Graph, like shown below, it first visits all the children of the starting node. These children are treated as the &quot;second layer&quot;.
Unlike <a target="_blank" href="/graphs-in-java-depth-first-search-dfs/">Depth-First Search</a> (DFS), BFS doesn't aggressively go though one branch until it reaches the end, rather when we start the search from a node, it visits all the unvisited neighbors of that node before proceeding to all the unvisited neighbors of another node:
<img src="https://s3.stackabuse.com/media/articles/bfs-gif.gif" alt="">
<h2 id="implementation">Implementation</h2>
We'll use graphs implemented via an adjacency list, like we used for DFS. Also, we need to add the <code>visited</code> attribute alongside the <code>visit()</code> and <code>univisit()</code> methods to our <code>Node</code> class:
<pre><code class="hljs">public class Node {
 int n;
 String name;
 boolean visited;

 Node(int n, String name) {
 this.n = n;
 this.name = name;
 visited = false;
 }

 void visit() {
 visited = true;
 }

 void unvisit() {
 visited = false;
 }
}
</code></pre>
Now, let's define a <code>Graph</code>:
<pre><code class="hljs">public class Graph {

 // Each node maps to a list of all his neighbors
 private HashMap&lt;Node, LinkedList&lt;Node&gt;&gt; adjacencyMap;
 private boolean directed;

 public Graph(boolean directed) {
 this.directed = directed;
 adjacencyMap = new HashMap&lt;&gt;();
 }

 // ...
}
</code></pre>
Now, let's add the method <code>addEdge()</code>. We'll use two methods, a helper method and the actual method.
In the helper method, we'll also make a check for possible duplicate edges. Before adding an edge between <code>A</code> and <code>B</code>, we'll first remove it and only then add it. If it existed (we're adding a duplicate edge), it was removed and after adding it again, there's only one.
Though, if it didn't exist, removing a non-existing edge will result in a <code>NullPointerException</code> so we're introducing a temporary copy of the list:
<pre><code class="hljs">public void addEdgeHelper(Node a, Node b) {
 LinkedList&lt;Node&gt; tmp = adjacencyMap.get(a);

 if (tmp != null) {
 tmp.remove(b);
 }
 else tmp = new LinkedList&lt;&gt;();
 tmp.add(b);
 adjacencyMap.put(a,tmp);
}

public void addEdge(Node source, Node destination) {

 // We make sure that every used node shows up in our .keySet()
 if (!adjacencyMap.keySet().contains(source))
 adjacencyMap.put(source, null);

 if (!adjacencyMap.keySet().contains(destination))
 adjacencyMap.put(destination, null);

 addEdgeHelper(source, destination);

 // If a graph is undirected, we want to add an edge from destination to source as well
 if (!directed) {
 addEdgeHelper(destination, source);
 }
}
</code></pre>
Finally, we'll have the <code>printEdges()</code>, <code>hasEdge()</code> and <code>resetNodesVisited()</code> helper methods, which are pretty straightforward:
<pre><code class="hljs">public void printEdges() {
 for (Node node : adjacencyMap.keySet()) {
 System.out.print(&quot;The &quot; + node.name + &quot; has an edge towards: &quot;);
 for (Node neighbor : adjacencyMap.get(node)) {
 System.out.print(neighbor.name + &quot; &quot;);
 }
 System.out.println();
 }
}

public boolean hasEdge(Node source, Node destination) {
 return adjacencyMap.containsKey(source) &amp;&amp; adjacencyMap.get(source).contains(destination);
}

public void resetNodesVisited(){
 for(Node node : adjacencyMap.keySet()){
 node.unvisit();
 }
}
</code></pre>
Let's examine the BFS algorithm on the following undirected graph:
<pre><code class="hljs">Node 0 has neighbors: 1, 3, 2
Node 1 has neighbors: 0
Node 2 has neighbors: 3, 0
Node 3 has neighbors: 2, 0
</code></pre>
We can pick any node to start from, so let's start with 1. We repeat the process of adding and removing nodes from the queue until the queue is empty.
<blockquote>
A Queue is a FIFO (first-in-first-out) data structure. It works just like a real-life queue, and so entries are processed (removed from the queue) one by one in the order in which they were added.
</blockquote>
This is a very convenient data structure for BFS since we want to process nodes in the order in which we visit them, making sure that we process nodes &quot;closer&quot; to the starting node first.
Since they are added to the queue before any nodes &quot;further&quot; away from the starting node are added to the queue, we know the closer ones will be processed first.
<ol>
<li>We start off by having a queue that contains only node 1</li>
</ol>
<img src="https://stackabuse.s3.amazonaws.com/media/graphs-in-java-breadth-first-search-(bfs)-2.png" alt="">
<ol start="2">
<li>Remove the first element from the queue, in this case 1, mark it as visited</li>
<li>Add all 1's unvisited neighbors to the queue (only 0)</li>
</ol>
<img src="https://stackabuse.s3.amazonaws.com/media/graphs-in-java-breadth-first-search-(bfs)-3.png" alt="">
<ol start="4">
<li>Remove the first element from the queue, in this case 0, mark it as visited</li>
<li>Add all 0's unvisited neighbors to the queue (nodes 3 and 2, 1 has been marked as visited already)</li>
</ol>
<img src="https://stackabuse.s3.amazonaws.com/media/graphs-in-java-breadth-first-search-(bfs)-4.png" alt="">
<ol start="6">
<li>Remove the first element from the queue, in this case 3, mark it as visited</li>
<li>Add all 3's unvisited neighbors to the queue (there are none)</li>
</ol>
<img src="https://stackabuse.s3.amazonaws.com/media/graphs-in-java-breadth-first-search-(bfs)-5.png" alt="">
<ol start="8">
<li>Remove the first element from the queue, in this case 2, mark it as visited</li>
<li>Add all 2's unvisited neighbors to the queue (again, there are none)</li>
<li>The queue is now empty, BFS has finished</li>
</ol>
Our nodes are visited in the <code>1-0-3-2</code> order. It should be obvious that set of steps 2-3, 4-5, 6-7, and 8-9 are the same and that step 10 is our loop termination condition. Viewed in this way, it should be easy to write code for our <code>breadthFirstSearch(Node node)</code> method.
There are several types of <code>Queue</code> implementations in Java, but we'll use a <code>LinkedList</code> instead, since it provides all the necessary methods.
We're adding the following method to our <code>Graph</code> class:
<pre><code class="hljs">void breadthFirstSearch(Node node) {

 // Just so we handle receiving an uninitialized Node, otherwise an
 // exception will be thrown when we try to add it to queue
 if (node == null)
 return;

 // Creating the queue, and adding the first node (step 1)
 LinkedList&lt;Node&gt; queue = new LinkedList&lt;&gt;();
 queue.add(node);

 while (!queue.isEmpty()) {
 Node currentFirst = queue.removeFirst();

 // In some cases we might have added a particular node more than once before
 // actually visiting that node, so we make sure to check and skip that node if we have
 // encountered it before
 if (currentFirst.isVisited())
 continue;

 // Mark the node as visited
 currentFirst.visit();
 System.out.print(currentFirst.name + &quot; &quot;);

 LinkedList&lt;Node&gt; allNeighbors = adjacencyMap.get(currentFirst);

 // We have to check whether the list of neighbors is null before proceeding, otherwise
 // the for-each loop will throw an exception
 if (allNeighbors == null)
 continue;

 for (Node neighbor : allNeighbors) {
 // We only add unvisited neighbors
 if (!neighbor.isVisited()) {
 queue.add(neighbor);
 }
 }
 }
 System.out.println();
}
</code></pre>
Now we create our example graph in code and check whether our method works as expected:
<pre><code class="hljs">public class GraphShow {
 public static void main(String[] args) {

 Graph graph = new Graph(false);
 Node a = new Node(0, &quot;0&quot;);
 Node b = new Node(1, &quot;1&quot;);
 Node c = new Node(2, &quot;2&quot;);
 Node d = new Node(3, &quot;3&quot;);
 Node e = new Node(4, &quot;4&quot;);

 graph.addEdge(a,d);
 graph.addEdge(a,b);
 graph.addEdge(a,c);
 graph.addEdge(c,d);

 graph.breadthFirstSearch(b);
 }
}
</code></pre>
Output:
<pre><code class="hljs">1 0 3 2
</code></pre>
If you read the DFS article then you may recall that we encountered a situation where in an unconnected graph, not all of the nodes would be printed out since the algorithm would go through all the nodes it can, and then stop.
The same thing happens with BFS, and this can also happen when graphs are directed, sometimes we can't reach all the nodes. Sometimes this is the behavior we're looking for, but sometimes we want all of the nodes to be visited.
We'll do the same thing as we did in DFS, i.e. we'll keep calling BFS as long as there are any unvisited nodes. We'll make a new <code>breadthFirstSearchModified(Node node)</code> method that does this for us:
<pre><code class="hljs">void breadthFirstSearchModified(Node node) {
 breadthFirstSearch(node);

 for (Node n : adjacencyMap.keySet()) {
 if (!n.isVisited()) {
 breadthFirstSearch(n);
 }
 }
}
</code></pre>
<pre><code class="hljs">public class GraphShow {
 public static void main(String[] args) {

 Graph graph = new Graph(false);
 Node a = new Node(0, &quot;0&quot;);
 Node b = new Node(1, &quot;1&quot;);
 Node c = new Node(2, &quot;2&quot;);
 Node d = new Node(3, &quot;3&quot;);
 Node e = new Node(4, &quot;4&quot;);

 graph.addEdge(a,d);
 graph.addEdge(a,b);
 graph.addEdge(c,e);

 System.out.println(&quot;Using the unmodified version of BFS we get:&quot;);
 graph.breadthFirstSearch(a);

 graph.resetNodesVisited();
 System.out.println(&quot;Using the modified version of BFS we get:&quot;);
 graph.breadthFirstSearchModified(a);
 }
}
</code></pre>
Output:
<pre><code class="hljs">Using the unmodified version of BFS we get:
0 3 1
Using the modified version of BFS we get:
0 3 1
4 2
</code></pre>
<blockquote>
There is also something called a &quot;bidirectional&quot; BFS search. This is useful when we want to find the shortest path between two vertices (nodes).
This is achieved by simultaneously (in different threads) running a BFS from the starting node and the destination node. This, in theory, finds the shortest path between two nodes twice as fast as running BFS just from the starting node.
</blockquote>
Note: Same as with DFS, if we want to go through the neighbors in a particular order (instead of the order in which the edges were added), we can use a <code>PriorityQueue</code> instead of a <code>LinkedList</code> for the list of neighbors.
The <a target="_blank" href="/graphs-in-java-depth-first-search-dfs#orderingneighbors">code is the same</a>, we just have to implement <code>Comparable</code> and add a <code>compareTo()</code> method to our <code>Node</code> class.
<h2 id="conclusion">Conclusion</h2>
Graphs are a convenient way to store certain types of data. The concept was ported from mathematics and appropriated for the needs of computer science.
Due to the fact that many things can be represented as graphs, graph traversal has become a common task, especially used in data science and machine learning.
Breadth-First Search is one of the few graph traversal algorithms and visits nodes &quot;layer-by-layer&quot;. Unlike Depth-First Search, BFS doesn't aggressively go through one branch until it reaches the end, rather when we start the search from a node, it visits all the unvisited neighbors of that node before proceeding to all the unvisited neighbors of another node.