<h2 id="introduction">Introduction</h2>
Conditional statements and loops are a very important tool in programming. There aren't many things we could do with code that can only execute line-by-line.
That's what &quot;flow control&quot; means - guiding the execution of our program, instead of letting it execute line-by-line regardless of any internal or external factors. Every programming language supports some form of flow control, if not explicitly via <code>if</code>s and <code>for</code>s or similar statements - then it implicitly gives us the tools to create such constructs, i.e. low-level programming languages usually achieve that affect with a lot of <code>go-to</code> commands.
<blockquote>
Loops were a concept used long before computer programming was even a thing, but the first person to use a software loop was Ada Lovelace, commonly known by her maiden name - Byron, while calculating <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Bernoulli_number">Bernoulli numbers</a>, back in the 19th century.
</blockquote>
In Java, there are several ways to control the flow of the code:
<ul>
<li><a target="_blank" href="/java-flow-control-if-and-if-else-statements">if and if-else statements</a></li>
<li><a target="_blank" href="/flow-control-in-java-the-switch-statement">switch statements</a></li>
<li><a target="_blank" href="/java-flow-control-while-and-do-while-statements/"><code>while</code> and <code>do-while</code> statements</a></li>
<li><a target="_blank" href="/java-flow-control-for-and-for-each-loops/"><code>for</code> and <code>enhanced for</code> statements</a></li>
<li><a target="_blank" href="/java-flow-control-break-and-continue-statements/"><code>break</code> and <code>continue</code> statements</a></li>
</ul>
<h2 id="theswitchstatement">The switch Statement</h2>
If we wish to compare a value to multiple values and execute code based on their equality, we could do something along the lines of:
<pre><code class="hljs">String input = &quot;someCommand&quot;;

if (input.equals(&quot;date&quot;)) {
 System.out.println(&quot;The current date is: &quot; + new Date());
} else if (input.equals(&quot;help&quot;)) {
 System.out.println(&quot;The possible commands are...&quot;);
} else if (input.equals(&quot;list&quot;)) {
 System.out.println(&quot;The files in this directory are...&quot;);
} else if (input.equals(&quot;exit&quot;)) {
 System.out.println(&quot;Exiting application...&quot;);
} else {
 System.out.println(&quot;Command Not Supported&quot;);
}
</code></pre>
This can quickly become cumbersome and unreadable. The <code>switch</code> statement was introduced to us precisely to avoid this whenever possible. This statement is used when we have several different things that we want executed based on the value of a single expression:
<pre><code class="hljs">switch(variable) { 
 case constant1:
 // Do something if the variable is equal to constant1. 
 // constant1 must be of same type as variable
 // or easily converted to, such as Integer -&gt; int
 break; 
 case constant2:
 // Some code
 break; 
 ... 
 default: 
 // Some code
 break;
}
</code></pre>
The variable passed as the <code>switch</code> argument is the variable or expression whose value we are comparing. That value is compared to each of the <code>case</code> values. If the variable we're checking matches any of the cases, the code following that case is executed. We can have as many <code>case</code> statements as we want.
There are four new keywords we're introduced to here: <code>switch</code>, <code>case</code>, <code>break</code>, and <code>default</code>.
<h3 id="switch">switch</h3>
The <code>switch</code> statement typically accepts a variable, though it can also accept an expression if it returns an accepted type:
<pre><code class="hljs">// Comparing the value 5 with case values
switch(5) {
 // Cases
}

int x = 5;
int y = 10;

// Comparing the value 15 with case values
switch(x+y) {
 // Cases
}

// Booleans are not supported by switch statements, 
// so this won&#x27;t compile
switch(!true) {
 // Cases
}
</code></pre>
If we pass a <code>null</code> value to the <code>switch</code>, a <code>NullPointerException</code> will arise.
<h3 id="case">case</h3>
The <code>case</code> label's value must be a compile-time constant. This means that for all <code>case</code> values, we must either use literals/constants (i.e. &quot;abc&quot;, 5, etc.) or variables that have been declared <code>final</code> and assigned a value:
<pre><code class="hljs">final int i = 5;
int y = 15;
final int z;
z = 25;

int x = 10;
switch(x) {
 case i:
 // i can&#x27;t be changed at any point due to the
 // `final` modifier, will compile
 break;
 case y:
 // Won&#x27;t compile as `y` isn&#x27;t a compile-time constant
 break;
 case 10+10:
 // Compiles, as 10+10 is a compile-time constant
 break;
 case z:
 // Doesn&#x27;t compile as z wasn&#x27;t initialized with
 // its declaration, thus it isn&#x27;t considered to
 // be a compile-time constant
 break;
 case null:
 // Doesn&#x27;t compile, there can&#x27;t be a null case
 break;
}
</code></pre>
The cases must all be unique, otherwise Java the code won't compile. If the cases weren't unique, there would be no way to know which case to execute among the duplicate values.
<h3 id="break">break</h3>
The <code>break</code> keyword is used to break the flow of the code within cases. Once the <code>switch</code> statement has found a case that matches the passed variable, it proceeds to execute case code until either the first <code>break</code> keyword is encountered or the end of the <code>switch</code> block itself.
For example:
<pre><code class="hljs">int ourNumber = 1;

switch(ourNumber) {
 case 1:
 System.out.println(&quot;One&quot;);
 case 2:
 System.out.println(&quot;Two&quot;);
 case 3:
 System.out.println(&quot;Three&quot;);
 break;
 case 4:
 System.out.println(&quot;Four&quot;);
}
</code></pre>
The output of this code is:
<pre><code class="hljs">One
Two
Three
</code></pre>
In this example, the flow of execution &quot;falls through&quot; from the first case statement (which matched the <code>ourNumber</code> value) to the <code>break</code> statement.
This can sometimes lead to unwanted cases being executed, so we should be careful to add <code>break</code> statements, and a good idea is to add them by default in every <code>case</code>, and remove them later if we do want to execute multiple cases for some inputs. More info on the <code>break</code> statement can be found <a href="#break">here</a>.
If we did want the same code executed for multiple cases, this is a common pattern used:
<pre><code class="hljs">...
case &quot;a&quot;:
case &quot;b&quot;:
 System.out.println(&quot;Variable is equal to constant1 or constant2!&quot;);
 break;
...
</code></pre>
This would execute the <code>System.out.println</code> line if our variable is equal to either <code>&quot;a&quot;</code> or if it's equal to <code>&quot;b&quot;</code>.
<h3 id="default">default</h3>
The <code>default</code> case is a piece of code that <code>switch</code> executes if the variable we've passed to it doesn't match any of the given cases. This statement is optional, though highly recommended to avoid situations where user-defined input breaks the whole flow of the application.
<h3 id="accepteddatatypes">Accepted Data Types</h3>
The <code>variable</code> passed as a <code>switch</code> argument can be one of the following:
<ul>
<li>char</li>
<li>byte</li>
<li>short</li>
<li>int</li>
<li>Integer</li>
<li>Short</li>
<li>Byte</li>
<li>Character</li>
<li>enum</li>
<li>String</li>
</ul>
This is a huge jump from the <code>if</code> and <code>else-if</code> statements, which only support <code>boolean</code> expressions.
That being said, we can easily rewrite the <code>if</code>/<code>if-else</code> example from the beginning of this article:
<pre><code class="hljs"> switch(&quot;someCommand&quot;) {
 case &quot;date&quot;:
 System.out.println(&quot;The current date is: &quot; + new Date());
 break;
 case &quot;help&quot;:
 System.out.println(&quot;The possible commands are...&quot;);
 break;
 case &quot;list&quot;:
 System.out.println(&quot;The files in this directory are...&quot;);
 break;
 case &quot;exit&quot;:
 System.out.println(&quot;Exiting application...&quot;);
 break;
 default:
 System.out.println(&quot;Command Not Supported&quot;);
 break;
 }
</code></pre>
Or, as another example, we could pass an integer and replace this chain of <code>if</code> and <code>else-if</code> blocks with a more readable counterpart:
<pre><code class="hljs">int ourNumber = 4;

if (ourNumber == 1) {
 System.out.println(&quot;One&quot;);
}
else if (ourNumber == 2) {
 System.out.println(&quot;Two&quot;);
}
else if (ourNumber == 3) {
 System.out.println(&quot;Three&quot;);
}
else if (ourNumber == 4) {
 System.out.println(&quot;Four&quot;);
}
else {
 System.out.println(&quot;Larger than 4&quot;);
}
</code></pre>
The equivalent <code>switch</code> statement would look like the following:
<pre><code class="hljs">switch(ourNumber) {
 case 1:
 System.out.println(&quot;One&quot;);
 break;
 case 2:
 System.out.println(&quot;Two&quot;);
 break;
 case 3:
 System.out.println(&quot;Three&quot;);
 break;
 case 4:
 System.out.println(&quot;Four&quot;);
 break;
 default:
 System.out.println(&quot;Larger than 4&quot;);
 break;
}
</code></pre>
It's clear that if <code>ourNumber</code> is equal to 1, the code after <code>case 1:</code> will be executed, and &quot;One&quot; will be printed to the standard output.
Note: Unlike other data types, Strings aren't compared with the <code>==</code> operator, but with the <code>.equals()</code> method when checking against all the cases. This is done so that the actual value of the strings are compared, and not the memory location.
<h3 id="nestedswitchstatements">Nested switch Statements</h3>
We can nest multiple <code>switch</code> statements.
<pre><code class="hljs">switch(var1) {
 case constant1:
 switch(var2) {
 // ...
 }
 break;
 case constant2:
 ...
}
</code></pre>
<h3 id="lambdaexpressions">Lambda Expressions</h3>
Java 12 has a new, more concise way of handling <code>switch</code> statements using Lambda Expressions.
By using <code>switch</code> statements in this way, breaks are no longer necessary, and returning a value is more readable. This is only available as a preview option currently. A typical new type of switch would look something like this:
<pre><code class="hljs">switch(ourNumber) {
 case 7, 3, 8, 4 -&gt; System.out.println(&quot;Very popular lucky number&quot;);
 case 5, 13, 9, 6 -&gt; System.out.println(&quot;Kind of popular lucky number&quot;);
 default -&gt; System.out.println(&quot;Not all that popular&quot;);
}

// Or something like:
String s = switch(ourNumber) {
 case 7, 3, 8, 4 -&gt; &quot;Very popular lucky number&quot;;
 // ...
}
System.out.println(s);
</code></pre>
<h2 id="conclusion">Conclusion</h2>
Flow control in code is essential for absolutely every application. Statements that alter the flow of code are fundamental building blocks and every aspiring developer should be completely in control/aware of how they work.

Olivera Popović

Java Flow Control: The switch Statement

<h2 id="introduction">Introduction</h2>
Conditional statements and loops are a very important tool in programming. There aren't many things we could do with code that can only execute line-by-line.
That's what &quot;flow control&quot; means - guiding the execution of our program, instead of letting it execute line-by-line regardless of any internal or external factors. Every programming language supports some form of flow control, if not explicitly via <code>if</code>s and <code>for</code>s or similar statements - then it implicitly gives us the tools to create such constructs, i.e. low-level programming languages usually achieve that affect with a lot of <code>go-to</code> commands.
<blockquote>
Loops were a concept used long before computer programming was even a thing, but the first person to use a software loop was Ada Lovelace, commonly known by her maiden name - Byron, while calculating <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Bernoulli_number">Bernoulli numbers</a>, back in the 19th century.
</blockquote>
<code>go-to</code> commands are to be avoided in most situations, whenever we're using a programming language that gives us the tools to avoid it, like Java and all remotely similar languages do (there's a slight exception to this rule when breaking <a href="#breakingnestedloops">nested loops</a>).
In Java, there are several ways to control the flow of the code:
<ul>
<li><a target="_blank" href="/java-flow-control-if-and-if-else-statements">if and if-else statements</a></li>
<li><a target="_blank" href="/flow-control-in-java-the-switch-statement">switch statements</a></li>
<li><a target="_blank" href="/java-flow-control-while-and-do-while-statements/"><code>while</code> and <code>do-while</code> statements</a></li>
<li><a target="_blank" href="/java-flow-control-for-and-for-each-loops/"><code>for</code> and <code>enhanced for</code> statements</a></li>
<li><a target="_blank" href="/java-flow-control-break-and-continue-statements/"><code>break</code> and <code>continue</code> statements</a></li>
</ul>
<h2 id="theifstatement">The if Statement</h2>
The <code>if</code> statement is probably the most common form of flow control, regardless of the language. It's very simple and intuitive:
<pre><code class="hljs">if(true) {
 //execute this code block if the argument/expression is true
 //some more code
}
</code></pre>
Since in a lot of cases, only a single line needs to be executed, you can skip using the curly brackets and a block of code and simply indent the next line, though this only works for a single line:
<pre><code class="hljs">if(true) 
 System.out.println(&quot;Inside the if block&quot;);
 System.out.println(&quot;I have nothing to do with the if block!&quot;);
System.out.println(&quot;Neither do I!&quot;);
</code></pre>
Typically, we don't input <code>boolean</code> values like in these examples, but rather, we use an expression:
<pre><code class="hljs">if(username != null)
 System.out.println(username);
if(argument &gt;= 10) 
 System.out.println(&quot;The input is higher or equal than 10&quot;);
</code></pre>
If the expression is <code>false</code>, the code belonging to the <code>if</code> statement is simply skipped:
<pre><code class="hljs">if(1 &gt; 5)
 System.out.println(&quot;Hello&quot;);
System.out.println(&quot; World!&quot;);
</code></pre>
And the output is:
<pre><code class="hljs"> World!
</code></pre>
<h2 id="theifelsestatement">The if-else Statement</h2>
We rarely wish to simply skip a piece of code if the expression is evaluated to be <code>false</code>. Typically, we want to do something <code>else</code> in that case:
<pre><code class="hljs">if(expression) { 
 //code that executes only if the expression is true
}
else {// optional
 //code that executes only if the expression is false
}
</code></pre>
Of course, you can use the <code>else</code> statement in conjunction with the shortened <code>if</code> statement:
<pre><code class="hljs">if(expression) 
 //code that executes only if the expression is true
else
 //code that executes only if the expression is false 
</code></pre>
However this is unrecommended to if you're not dealing with simple statements, especially with nested <code>if</code>s since it's hard to figure out &quot;which <code>if</code> does a particular <code>else</code> belong to&quot;. Using brackets will take ambiguity out of the problem if you find this approach unreadable.
The <code>else</code> statement statement is optional, so there's no need to write an empty <code>else {}</code> block if we don't want anything to happen if is the <code>expression</code> is false.
The <code>else</code> statement is intrinsically tied to the <code>if</code> statement and can't exist without it. It must appear right after the <code>if</code> statement otherwise an &quot;else without if&quot; compiler error will appear.
In most cases, we want to compare something for equality - whether one variable has the same value as another or whether it's smaller/larger than another:
<pre><code class="hljs">String s = &quot;smol&quot;;

if (s.length() &gt; 8)
 System.out.println(&quot;s has too many characters!&quot;);
else 
 System.out.println(&quot;Ok, so basically, s is very &quot; + s);
</code></pre>
The <code>&gt;</code> operator here has the usual &quot;greater than&quot; meaning, and Java supports the usual group of relational operators. These include <code>&lt;</code>, <code>&gt;</code>, <code>&lt;=</code>, <code>=&gt;</code>, <code>==</code> checks for equality and <code>!=</code> checks for inequality.
Note: Make sure to use <code>==</code> in <code>if</code> statements instead of <code>=</code>, or else you may assign a value instead of compare it.
<pre><code class="hljs">2 &lt; 5 //true
2 &lt; 2 //false
2 &lt;= 2 //true
2 == 3 //false
2 != 3 //true
</code></pre>
Note: Most of the time, we don't compare <code>String</code> variables using <code>==</code> but with the <code>.equals()</code> method. <code>==</code> checks for object reference equality. For primitive types (<code>int</code>, <code>char</code>, etc.) it's the same as checking whether they have the same value, but with Strings it most commonly isn't.
<pre><code class="hljs">if(string1.equals(string2))
 //code to be executed if the strings are equal by value
</code></pre>
<h3 id="nestedifstatements">Nested if Statements</h3>
We can have more than one <code>if</code> statement connected, either by nesting (putting one <code>if</code> statement inside another) or adding an <code>else if</code> at the end of our previous <code>if</code>:
<pre><code class="hljs">int ourNumber = 10;

if(ourNumber &gt; 8){ 
 if(ourNumber % 2 == 0){
 System.out.println(&quot;The number is larger than 8 and even&quot;);
 }
}
else if (ourNumber == 1) {
 System.out.println(&quot;1 is less than 8, so the previous if block isn&#x27;t executed&quot;);
}
else {
 System.out.println(&quot;ourNumber is less than 8 and different than 1&quot;);
}
</code></pre>
<code>else</code> blocks always &quot;belong&quot; to the <code>if</code> of the same level, so the <code>else if (ourNumber == 1)</code> in our code belongs to the <code>if(ourNumber &gt; 8)</code> and not the nested <code>if</code> that checks whether the number is even.
You can have as many <code>else if</code> blocks as you'd like, but only one <code>else</code> block, which comes last. Each <code>if</code>, <code>else if</code> and <code>else</code> block that evaluates to <code>true</code> will execute:
<pre><code class="hljs">
</code></pre>
<h3 id="multipleexpressionsinasingleifstatement">Multiple Expressions in a Single if Statement</h3>
Another very useful thing is the ability to check multiple conditions in a single <code>if</code>:
<pre><code class="hljs">int ourNumber = 10;

if(ourNumber &gt; 5 &amp;&amp; (ourNumber % 2 == 0)){
 System.out.println(&quot;The number is larger than 8 and even&quot;);
}
</code></pre>
The <code>&amp;&amp;</code> operator is one of the logical operators Java supports. <code>boolExpr</code> is used as shorthand for <code>boolean expression</code>. Reminder: a <code>boolean</code> expression is an expression that can be evaluated as <code>true</code> or <code>false</code>, i.e. it can also be an expression containing a logical operator, as we can see here:
<ul>
<li><code>!boolExpr</code> - <code>!</code> is negation, it evaluates a <code>true</code> expression to <code>false</code> and vice versa.</li>
<li><code>boolExpr1 &amp; boolExpr2</code> - the AND operator evaluates to <code>true</code> if both expressions are <code>true</code>.</li>
<li><code>boolExpr1 | boolExpr2</code> - the OR operator evaluates to <code>true</code> if at least one of the expressions is <code>true</code>.</li>
<li><code>boolExpr1 &amp;&amp; boolExpr2</code> - the short-circuit AND operator evaluates to <code>true</code> only if <code>boolExpr1</code> and <code>boolExpr2</code> are both <code>true</code>. It's called a short-circuit operator because if the first expression is <code>false</code>, it won't even evaluate the second expression as the basic condition that both need to be <code>true</code> can never occur. With simple expressions, this doesn't affect the code in a meaningful way, but in production code, both expressions can be costly operations and this approach can significantly optimize code.</li>
<li><code>boolExpr1 || boolExpr2</code> - the short-circuit OR operator evaluates to <code>true</code> if at least one of <code>boolExpr1</code> and <code>boolExpr2</code> is <code>true</code>. A short-circuit version of the <code>|</code> operator.</li>
<li><code>boolExpr1 ^ boolExpr2</code> - the XOR operator evaluates to <code>true</code> only if <code>boolExpr1</code> and <code>boolExpr2</code> are evaluate as differently, i.e. if only one of them is <code>true</code> and the other one is <code>false</code>.</li>
</ul>
<pre><code class="hljs">true &amp;&amp; false //false
(2 &lt; 5) &amp;&amp; (2 != 3) //true
false || true //true
true &amp;&amp; ((false || false) ^ true) //true
(true &amp;&amp; false) || false // false
</code></pre>
It's highly recommended to use parentheses whenever it makes sense to use them. The last example works the same without parentheses but relying on <a rel="nofollow" target="_blank" href="https://docs.oracle.com/javase/tutorial/java/nutsandbolts/operators.html">operator precedence</a> is extremely risky and leads to unreadable code.
<h2 id="ternaryconstructs">Ternary Constructs</h2>
The only ternary operator (an operator that takes three operands) in Java is the <code>?:</code> operator. It works like a very compact <code>if-else</code> statement.
<pre><code class="hljs">int max = 0;
if (a &gt; b)
 max = a;
else max = b;

//can be written as
int max = (a &gt; b) ? a : b; 
</code></pre>
Here's how a ternary construct generally looks like:
<pre><code class="hljs">(expression) ? returnValueIfTrue : returnValueIfFalse
</code></pre>
Ternary constructs can work without parentheses as well, though it's generally more readable to use parentheses:
<pre><code class="hljs">int max = a &gt; b ? a : b;
</code></pre>
You can also use ternary constructs to modify variables:
<pre><code class="hljs">System.out.println(&quot;10% discount for orders above $50!&quot;);
double orderPrice = 55;
double finalPrice = orderPrice &gt; 50 ? orderPrice*09 : orderPrice;
System.out.println(&quot;Your final price is $&quot; + finalPrice);
</code></pre>
And the output is:
<pre><code class="hljs">Your final price is $49.5
</code></pre>
Using the construct, we can also call methods:
<pre><code class="hljs">public void someMethod() {
 String userRole = &quot;Admin&quot;;
 String result = userRole.equals(&quot;Admin&quot;) ? greetAdmin() : greetUser();
 System.out.println(result);
}

static String greetAdmin() {
 return &quot;Hello Admin!&quot;;
}
static String greetUser() {
 return &quot;Hello User!&quot;;
}
</code></pre>
Logically, this would result in:
<pre><code class="hljs">Hello Admin!
</code></pre>
<h3 id="nestedternaryconstructs">Nested Ternary Constructs</h3>
<pre><code class="hljs">System.out.println(&quot;10% discount for all orders above $50 and additional $5 off if your order exceedes 2 items!&quot;);
double orderPrice = 140;
int quantity = 5;
double finalPrice = (orderPrice &gt; 50) ? (quantity &gt; 2) ? (orderPrice*0.9)-5 : orderPrice*0.9 : orderPrice;
System.out.println(&quot;Your final price is: $&quot; + finalPrice);
</code></pre>
Since both conditions are <code>true</code>, the output is:
<pre><code class="hljs">10% discount for all orders above $50 and additional $5 off if your order exceedes 2 items!
Your final price is: $121.0
</code></pre>
However, this approach is horribly unreadable. If possible, avoid nesting ternary constructs, though if you must, break it down into simpler blocks. For an example, this example can be made a bit more readable:
<pre><code class="hljs">System.out.println(&quot;10% discount for all orders above $50 and additional $5 off if your order exceedes 2 items!&quot;);
double orderPrice = 140;
int quantity = 5;
double finalPrice = (orderPrice &gt; 50) ?
 (quantity &gt; 2) ?
 (orderPrice*0.9)-5 : orderPrice*0.9
 : orderPrice;
System.out.println(&quot;Your final price is: $&quot; + finalPrice);
</code></pre>
<h2 id="conclusion">Conclusion</h2>
Flow control in code is essential for absolutely every application. Statements such as <code>if</code> and <code>if-else</code> are fundamental building blocks and every aspiring developer should be completely in control/aware of how they work.

Java Flow Control: if and if-else Statements

<h2 id="introduction">Introduction</h2>
In this tutorial, we're going to learn how to use the <a rel="nofollow" target="_blank" href="https://trypyramid.com">Pyramid</a> framework in Python. It is an open source web development framework which uses the <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Model–view–controller">Model-View-Controller</a> (MVC) architecture pattern and is based on <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Web_Server_Gateway_Interface">Web Server Gateway Interface</a> (WSGI). The Pyramid framework has a lot of useful add-on packages that make web development a lot more convenient. Some other popular alternatives for web development in Python include <a rel="nofollow" target="_blank" href="https://www.djangoproject.com">Django</a> and <a rel="nofollow" target="_blank" href="http://flask.pocoo.org">Flask</a>.
<h2 id="prerequisites">Prerequisites</h2>
You need to have basic knowledge of HTML for this tutorial. If you do not have any prior experience with it, do not worry about it, you can still follow this tutorial and understand how Pyramid works, but to develop real world web applications you will have to go back and learn HTML.
<h2 id="architecture">Architecture</h2>
Before we move on and see the code, let's first understand WSGI and MVC.
WSGI is basically a standard which defines the way in which a Python based web application interacts with a server. It governs the process of sending requests to a server, and receiving responses from a server.
MVC is an architectural pattern which modularizes your application; the model contains the data and business logic of your application, the view displays the relevant information to the user, and the controller is responsible for the interaction between the model and the view.
Google Maps is a perfect example of the MVC architecture. When we use the route-finding feature in Google Maps, the model contains the code for the algorithm which finds the shortest path from location A to location B, the view is the screen that is shown to you containing the map labeled with the route, and the controller contains the code that uses the shortest path found by the model and displays it to the user through the view. You can also view controller, as the code which receives a request from the view (by the user), forwards it to the model to generate a response, and then displays the response from the model back to the user through a view.
Besides WSGI and MVC, there are two more terms that you should be familiar with, which are &quot;routes&quot; and &quot;scripts&quot;. Routes allow your website to be divided into different webpages, with each webpage performing a different function.
Let's consider Facebook as an example. If you wish to view your messages, a new webpage with a different view is opened up for that, if you wish to view your own profile, a new webpage is opened for that, but they are all connected to your main website. That's done through routes. Each time you click on a button or link, you are redirected to a new webpage as specified by the routes in our application.
As for scripts, they simply include configuration settings for our application, and help in managing it.
We will learn more about all these terms when we create a basic web application using Pyramid. So, let's begin.
<h2 id="installation">Installation</h2>
Whenever we develop a web application that is to be deployed online, it is always considered a good practice to make a virtual environment first. The virtual environment contains all the libraries, or frameworks and all the other dependencies that are necessary for running the web app. This way, when you deploy your app to a server, you can simply re-install all those libraries on the server, for your application to run smoothly.
Let's create a virtual environment before we move forward. Install virtual environment module by running the command below in your terminal:
<pre><code class="hljs">$ pip install virtualenv
</code></pre>
To test that your installation was successful, run the following command:
<pre><code class="hljs">$ virtualenv --version
</code></pre>
If you see a version number printed to the console then the installation was successful (or <code>virtualenv</code> was already installed on your system).
To create a virtual environment, first navigate to the folder where you wish to create it, and then run the following command:
<pre><code class="hljs">$ virtualenv myvenv
</code></pre>
Note: You can name your virtual environment anything you want. Here we're using &quot;myenv&quot; for demonstration purposes only.
The last step is to activate your virtual environment. On Mac, run the following command in the terminal:
<pre><code class="hljs">$ source myvenv/bin/activate
</code></pre>
On a Windows machine, you can activate the environment with the following command:
<pre><code class="hljs">'Installation folder'\myvenv\Scripts\activate.bat
</code></pre>
Now that you have your virtual environment set up, let's install Pyramid in it. We will use the pip package manager for that:
<pre><code class="hljs">$ pip install pyramid
</code></pre>
Note: When you are done with working with the application and wish to deactivate your virtual environment, run the following command in the terminal:
<pre><code class="hljs">$ deactivate
</code></pre>
<h2 id="codingexercise">Coding Exercise</h2>
In this section, we will start off by coding a skeleton app to understand how the Pyramid apps are structured and how they communicate at a basic level. After that, we will see how to create applications with multiple views.
<h3 id="asimpleexampleofpythonpyramid">A Simple Example of Python Pyramid</h3>
<pre><code class="hljs"># intro.py
# Import necessary functions to run our web app

from wsgiref.simple_server import make_server
from pyramid.config import Configurator
from pyramid.response import Response

# This function receives a request from the user, and returns a response
def intro(request):
 return Response(&#x27;Hi, My name is Junaid Khalid&#x27;)

# This function will start a server on our computer (localhost), define the
# routes for our application, and also add a view to be shown to the user
def main():
 with Configurator() as config:

 config.add_route(&#x27;intro&#x27;, &#x27;/&#x27;)
 config.add_view(intro, route_name=&#x27;intro&#x27;)
 application = config.make_wsgi_app()

 # 8000 is the port number through which the requests of our app will be served
 server = make_server(&#x27;0.0.0.0&#x27;, 8000, application)
 server.serve_forever()

main()
</code></pre>
Note: The <code>Configurator</code> module is being used to connect a particular view to a specific route. For instance, on Facebook, the &quot;My Profile&quot; view would be different than the &quot;News Feed&quot; view, and they both have different URLs as well. This is exactly what a configurator does; connecting a specific URL/route to a particular view.
Then <code>make_server</code> methods is used to run our application on a local HTTP server on our machine, with an assigned port number.
The <code>intro</code> function is used to process the requests received from the user, process them, and return the response to the view. Any processing of the request before sending a response, can be done inside this function.
To run the above application on your workstation, go to the terminal and run the .py file we just created:
<pre><code class="hljs">$ python3 intro.py
</code></pre>
In my case, the filename is intro.py, but yours could be different depending on what you decided to name it.
Then open any web browser on your PC, and go to this address: <code>http://localhost:8000</code>. You should see a webpage with &quot;Hi, My name is Junaid Khalid&quot; written in a very aesthetically displeasing way. To make it look more pleasant, you can return HTML code as a response as well. For a simple example, let's edit intro function:
<pre><code class="hljs">def intro(request):
 return Response(&#x27;&lt;h2 style=&quot;text-align: center; font-family: verdana; color: blue;&quot;&gt;Hi, My name is Junaid Khalid.&lt;/h2&gt;&#x27;)
</code></pre>
Replace the intro function with the one above, and see the output now. A lot better, right? This was just an example. You can make it a lot better.
Note: When you make any change in the code, the server is not automatically going to log that. You will have to stop the server, and then restart it to see your changes take effect. To do that, open your terminal where the server is running and press <code>Control+C</code>, this will terminate the server. Then you can restart your server as usual to see the changes.
<h3 id="separatinganddisplayingmultipleviews">Separating and Displaying Multiple Views</h3>
In this section, we will add a few more views as well as remove our views from the main file (i.e. 'intro.py' file), and put them all in a new separate file ('all_views.py'). This will modularize our code, make it look cleaner, and will also allow us to add new views more easily. So, let's do it.
<pre><code class="hljs"># all_views.py
# Import necessary functions to run our web app
from pyramid.compat import escape
from pyramid.response import Response
from pyramid.view import view_config

# view_config functions tells Pyramid which route&#x27;s view is going to be defined in the function that follows
# the name of the function does not matter, you can name it whatever you like

@view_config(route_name=&#x27;intro&#x27;)
def home_page(request):
 header = &#x27;&lt;h2 style=&quot;text-align: center;&quot;&gt;Home Page&lt;/h2&gt;&#x27;
 body = &#x27;&lt;br&gt;&lt;br&gt;&lt;p style=&quot;text-align: center; font-family: verdana; color: blue;&quot;&gt;Hi, My name is Junaid Khalid.&lt;/p&gt;&#x27;
 body += &#x27;&lt;p style=&quot;text-align: center; font-family: verdana;&quot;&gt; This is my portfolio website.&lt;/p&gt;&#x27;
 footer = &#x27;&lt;p style=&quot;text-align: center; font-family: verdana;&quot;&gt;Checkout my &lt;a href=&quot;/jobs&quot;&gt;previous jobs&lt;/a&gt;.&lt;/p&gt;&#x27;

 # In the &#x27;a&#x27; tag, notice that the href contains &#x27;/jobs&#x27;, this route will be defined in the intro.py file
 # It is simply telling the view to navigate to that route, and run whatever code is in that view

 return Response(header + body + footer)

@view_config(route_name=&#x27;jobs&#x27;)
def job_history(request):
 header = &#x27;&lt;h2 style=&quot;text-align: center;&quot;&gt;Job History&lt;/h2&gt;&#x27;
 job1 = &#x27;&lt;p style=&quot;text-align: center; font-family: verdana;&quot;&gt;Jr. Software Developer at XYZ&lt;/p&gt;&#x27;

 return Response(header + job1)
</code></pre>
Note: At the beginner level, you can write the HTML code by following the strategy used above i.e. declare tags in different variables and simply concatenate them when sending back the response. At some point you'll likely want to use a templating engine, like <a rel="nofollow" target="_blank" href="https://palletsprojects.com/p/jinja/">Jinja</a> to make HTML generation much simpler.
Our application won't run just yet, we need to edit the intro.py file as well.
<pre><code class="hljs"># intro.py
# Import necessary functions to run our web app

from wsgiref.simple_server import make_server
from pyramid.config import Configurator
from pyramid.response import Response

def main():
 with Configurator() as config:
 # In add_route function, the first parameter defines the name of the route
 # and the second parameter defines the &#x27;route&#x27; or the page location
 config.add_route(&#x27;intro&#x27;, &#x27;/&#x27;)
 config.add_route(&#x27;jobs&#x27;, &#x27;/jobs&#x27;)

 # The scan function scans our project directory for a file named all_views.py
 # and connects the routes we provided above with their relevant views
 config.scan(&#x27;all_views&#x27;)

 application = config.make_wsgi_app()

 # The following lines of code configure and start a server which hosts our
 # website locally (i.e. on our computer)
 server = make_server(&#x27;0.0.0.0&#x27;, 8000, application)
 server.serve_forever()

main()
</code></pre>
As you can see, we have removed the code for our previous view. If we had declared all these views in a single file, the file would have looked a lot more cluttered. Both files look very clean now, and each file now serves a single purpose. Let's see what our web app looks like right now.
Output:
<img class= "img-responsive" src= "https://stackabuse.s3.amazonaws.com/media/introduction-python-pyramid-framework-1.png">
In the image above, we can see our home page. It is located at the route '<a href="http://localhost:8000">http://localhost:8000</a>'. It does not look very aesthetically pleasing, but as stated at the start of the tutorial, this was not our aim anyways. If we want to make it look aesthetic, we can add a lot of styling to it using HTML style attribute, or CSS, or use templates from Bootstrap.
Moving on, you can also see a hyperlink which has been named 'previous jobs'. Clicking that would take you to a new webpage with a different route. We will see the output of that in the next image.
Output:
<img class= "img-responsive" src= "https://stackabuse.s3.amazonaws.com/media/introduction-python-pyramid-framework-2.png">
The above image shows our Jobs page. It is located at the route <code>http://localhost:8000/jobs</code>. We specified this route in our 'intro.py' file. I have only added one job to show as an example.
<h2 id="conclusion">Conclusion</h2>
Pyramid is a Python based Web Development Framework to build web apps with ease. In this tutorial, we learned how to install Pyramid inside a virtual environment and make a basic Web Application using Pyramid which runs on a locally created server on our computer.
If you would like to go into more details, visit Pyramid's <a rel="nofollow" target="_blank" href="https://trypyramid.com/documentation.html">documentation</a> - it is quite elaborate and beginner friendly.

Muhammad Junaid Khalid

Introduction to the Python Pyramid Framework

Usman Malik

Python for NLP: Multi-label Text Classification with Keras

Mina Krivokuća

Minimax with Alpha-Beta Pruning in Python

Unit Testing in Java with JUnit 5

Python for NLP: Creating Multi-Data-Type Classification Models with Keras

There are a number of different ways to format strings in Python, one of which is done using the <code>%</code> operator, which is known as the string formatting (or interpolation) operator. In this article we'll show you how to use this operator to construct strings with a template string and variables containing your data.
<h2 id="theoperator">The % Operator</h2>
This way of working with text has been shipped with Python since the beginning, and it's also known as C-style formatting, as it originates from the C programming language. Another description for it is simple positional formatting.
The <code>%</code> operator tells the Python interpreter to format a string using a given set of variables, enclosed in a tuple, following the operator. A very simple example of this is as follows:
<pre><code class="hljs">&#x27;%s is smaller than %s&#x27; % (&#x27;one&#x27;, &#x27;two&#x27;)
</code></pre>
The Python interpreter substitutes the first occurrence of <code>%s</code> in the string by the given string &quot;one&quot;, and the second <code>%s</code> by the string &quot;two&quot;. These <code>%s</code> strings are actually placeholders in our &quot;template&quot; string, and they indicate that strings will be placed there.
As a first example, below we demonstrate using the Python REPL how to print a string value and a float value:
<pre><code class="hljs">&gt;&gt;&gt; print(&quot;Mr. %s, the total is %.2f.&quot; % (&quot;Jekyll&quot;, 15.53))
&#x27;Mr. Jekyll, the total is 15.33.&#x27;
</code></pre>
Just like the <code>%s</code> is a placeholder for strings, <code>%f</code> is a placeholder for floating point numbers. The &quot;.2&quot; before the <code>f</code> is what indicates how many digits we want displayed after the decimal point.
These are just two simple examples of what is possible, and a lot more placeholder types are supported. Here is the full list of placeholder types in more detail:
<h3 id="c">%c</h3>
This placeholder represents a single character.
<pre><code class="hljs">&gt;&gt;&gt; print(&quot;The character after %c is %c.&quot; % (&quot;B&quot;, &quot;C&quot;))
The character after B is C.
</code></pre>
Providing more than a single character as the variable here will raise an exception.
<h3 id="s">%s</h3>
This placeholder uses string conversion via <code>str()</code> prior to formatting. So any value that can be converted to a string via <code>str()</code> can be used here.
<pre><code class="hljs">&gt;&gt;&gt; place = &quot;New York&quot;
&gt;&gt;&gt; print(&quot;Welcome to %s!&quot; % place)
Welcome to New York!
</code></pre>
Here we only have a single element to be used in our string formatting, and thus we're not required to enclose the element in a tuple like the previous examples.
<h3 id="iandd">%i and %d</h3>
These placeholders represent a signed decimal integer.
<pre><code class="hljs">&gt;&gt;&gt; year = 2019
&gt;&gt;&gt; print(&quot;%i will be a perfect year.&quot; % year)
2019 will be a perfect year.
</code></pre>
Since this placeholder expects a decimal, it will be converted to one if a floating point value is provided instead.
<h3 id="u">%u</h3>
This placeholder represents an unsigned decimal integer.
<h3 id="o">%o</h3>
This placeholder represents an octal integer.
<pre><code class="hljs">&gt;&gt;&gt; number = 15
&gt;&gt;&gt; print(&quot;%i in octal is %o&quot; % (number, number))
15 in octal is 17
</code></pre>
<h3 id="x">%x</h3>
Represents a hexadecimal integer using lowercase letters (a-f).
<pre><code class="hljs">&gt;&gt;&gt; number = 15
&gt;&gt;&gt; print(&quot;%i in hex is %02x&quot; % (number, number))
15 in hex is 0f
</code></pre>
By using the &quot;02&quot; prefix in our placeholder, we're telling Python to print a two-character hex string.
<h3 id="x">%X</h3>
Represents a hexadecimal integer using uppercase letters (A-F).
<pre><code class="hljs">&gt;&gt;&gt; number = 15
&gt;&gt;&gt; print(&quot;%i in hex is %04X&quot; % (number, number))
15 in hex is 000F
</code></pre>
And like the previous example, by using the &quot;04&quot; prefix in our placeholder, we're telling Python to print a four-character hex string.
<h3 id="e">%e</h3>
Represents an exponential notation with a lowercase &quot;e&quot;.
<h3 id="e">%E</h3>
Represents an exponential notation with an uppercase &quot;e&quot;.
<h3 id="f">%f</h3>
Represents a floating point real number.
<pre><code class="hljs">&gt;&gt;&gt; price = 15.95
&gt;&gt;&gt; print(&quot;the price is %.2f&quot; % price)
the price is 15.95
</code></pre>
<h3 id="g">%g</h3>
The shorter version of <code>%f</code> and <code>%e</code>.
<h3 id="g">%G</h3>
The shorter version of <code>%f</code> and <code>%E</code>.
The placeholders shown above allow you to format strings by specifying data types in your templates. However, these aren't the only features of the interpolation operator. In the next subsection we'll see how we can pad our strings with spaces using the <code>%</code> operator.
<h3 id="aligningtheoutput">Aligning the Output</h3>
Up until now we've only shown how to format text strings by specifying simple placeholders. With the help of an additional numerical value, you can define the total space that shall be reserved on either side of a variable in the output string.
As an example the value of <code>%10s</code> reserves 10 characters, with the extra spacing on the left side of the placeholder, and a value of <code>%-10s</code> puts any extra space to the right of the placeholder. The single padding character is a space, and cannot be changed.
<pre><code class="hljs">&gt;&gt;&gt; place = &quot;London&quot;
&gt;&gt;&gt; print (&quot;%10s is not a place in France&quot; % place) # Pad to the left
 London is not a place in France
&gt;&gt;&gt; print (&quot;%-10s is not a place in France&quot; % place) # Pad to the right
London is not a place in France
</code></pre>
Dealing with numbers works in the same way:
<pre><code class="hljs">&gt;&gt;&gt; print (&quot;The postcode is %10d.&quot; % 25000) # Padding on the left side
The postcode is 25000.
&gt;&gt;&gt; print (&quot;The postcode is %-10d.&quot; % 25000) # Padding on the right side
The postcode is 25000 .
</code></pre>
Truncating strings and rounding numbers is the counterpart to padding. Have a look at <a target="_blank" href="/rounding-numbers-in-python/">Rounding Numbers in Python</a> in order to learn more about the traps that are hiding here.
<h2 id="conclusion">Conclusion</h2>
In this article we saw how the interpolation (aka formatting) operator is a powerful way to format strings, which allows you to specify data type, floating point precision, and even spacing/padding.

Frank Hofmann

Python String Interpolation with the Percent (%) Operator

<h2 id="introduction">Introduction</h2>
When getting dressed, as one does, you most likely haven't had this line of thought:
<blockquote>
Oh, it might have been a good idea to put on my underpants before getting into my trousers.
</blockquote>
That's because we're used to sorting our actions topologically. Or in simpler terms, we're used to logically deducing which actions have to come before or after other actions, or rather which actions are prerequisites for other actions.
For example, let's say that you want to build a house, the steps would look like this:
<ol>
<li>Lay down the foundation</li>
<li>Build walls with installations</li>
<li>Put in insulation</li>
<li>Put in decorations/facade</li>
</ol>
In that exact order - it's undisputed. You can't build walls if you don't have a foundation, and you can't put in insulation if there aren't any walls.
In this guide we will be covering Topological Sorting in Java.
<h2 id="introductiontographs">Introduction to Graphs</h2>
Since Topological Sorting is applied to Directed Acyclic Graphs (DAG), we first have to talk a bit about Graphs.
A Graph is simply a data structure that represents a set of objects that have certain relations between each other - the objects being represented by nodes (circles) and the individual relations by edges (the lines).
There are many different kinds of graphs, but for the problem at hand we need to learn what is a Directed Acyclic Graph. Let's dissect the big bad math term into smaller, more comprehensible segments.
<h3 id="directed">Directed</h3>
A graph is directed if every relation between 2 objects doesn't have to be bidirectional (it has to have a direction), unlike a unidirectional graph where every relation has to go both ways.
In the graph below, the relation <code>C-A</code> is unidirectional, which means <code>C</code> has a relation with <code>A</code>, and <code>A</code> has a relation with <code>C</code>.
<img src="https://stackabuse.s3.amazonaws.com/media/topological-sorting-in-java-1.png" alt="">
On the other hand, in the following graph, the relation <code>C-A</code> is directed, which means <code>A</code> has a relation with <code>C</code>, but <code>C</code> doesn't have a relation with <code>A</code>.
<img src="https://stackabuse.s3.amazonaws.com/media/topological-sorting-in-java-2.png" alt="">
Because of this difference, we have to strictly define what are the node's neighbors:
Undirected graph:
<blockquote>
​Two nodes (A and B) are neighboring nodes if an undirected path exists between them.
</blockquote>
Directed graph:
<blockquote>
​<code>A</code> is <code>B</code>'s neighbor if a direct, directed edge exists which leads from <code>B</code> to <code>A</code>. The first direct in this definition refers to the fact that the length of the path leading from <code>B</code> to <code>A</code> has to be strictly 1.
</blockquote>
<h3 id="acyclic">Acyclic</h3>
A given graph is acyclic only if a cycle does not exist. A cycle is a path for any node <code>X</code>, which starts at <code>X</code> and leads back to <code>X</code>. The following graph is not acyclic because it contains a cycle (<code>X-B-C-X</code>).
<img src="https://stackabuse.s3.amazonaws.com/media/topological-sorting-in-java-5.png" alt="">
<h2 id="basictopologicalsortingconcept">Basic Topological Sorting Concept</h2>
So how does topological sorting look when used on a graph, and why does the graph have to be acyclic for it to work?
To answer these questions, let's strictly define what it means to topologically sort a graph:
<blockquote>
A graph is topologically sortable if a sequence <code>a1</code>, <code>a2</code>, <code>a3</code>... exists (<code>ai</code> being graph nodes), where for every edge <code>ai</code>-&gt;<code>aj</code>, <code>ai</code> comes before <code>aj</code> in the sequence.
</blockquote>
If we say that actions are represented by nodes. The above definition would basically mean that an undisputable order execution must exist.
To better understand the logic behind topological sorting and why it can't work on a graph that contains a cycle, let's pretend we're a computer that's trying to topologically sort the following graph:
<img src="https://stackabuse.s3.amazonaws.com/media/topological-sorting-in-java-4.png" alt="">
<pre><code class="hljs"># Let's say that we start our search at node X
# Current node: X
step 1: Ok, i'm starting from node X so it must be at the beginning of the sequence.
 sequence: [X]

# The only available edge from X is X-&gt;B, so we 'travel' to B
# Current node: B
step 2: Right, B comes after X in the sequence for sure.
 sequence: [X,B]

# We travel to C using the edge B-&gt;C
# Current node: C
step 3: Same thing as the last step, we add C.
 sequence: [X,B,C]

# Current node: X
step 4: WHAT IN THE TARNATION, X AGAIN?
 sequence: [X,B,C,X]
</code></pre>
This is the reason why we can't topologically sort a graph that contains a cycle, because the following two statements are both true:
<ul>
<li>X comes before B</li>
<li>B comes before X</li>
</ul>
And because of that, we can't determine the absolute order of the given actions.
Now because we're familiar with the algorithm's concepts, let's take a look at the implementation in Java.
<h2 id="implementation">Implementation</h2>
First off, let's construct classes for defining nodes and graphs, and then using said classes, define the following graph:
<img src="https://stackabuse.s3.amazonaws.com/media/topological-sorting-in-java-3.png" alt="">
<pre><code class="hljs">public class Graph {
 private List&lt;Node&gt; nodes;

 public Graph() {
 this.nodes = new ArrayList&lt;&gt;();
 }

 public Graph(List&lt;Node&gt; nodes) {
 this.nodes = nodes;
 }

 public void addNode(Node e) {
 this.nodes.add(e);
 }

 public List&lt;Node&gt; getNodes() {
 return nodes;
 }

 public Node getNode(int searchId) {
 for (Node node:this.getNodes()) {
 if (node.getId() == searchId) {
 return node;
 }
 }
 return null;
 }

 public int getSize() {
 return this.nodes.size();
 }

 @Override
 public String toString() {
 return &quot;Graph{&quot; +
 &quot;nodes=&quot; + nodes +
 &quot;}&quot;;
 }
}
</code></pre>
The graph is pretty simple, we can instantiate it empty or with a set of nodes, add nodes, retrieve them and print them out.
Now, let's move on to the <code>Node</code> class:
<pre><code class="hljs">public class Node {
 private int id;
 private List&lt;Integer&gt; neighbors;

 public Node(int id) {
 this.id = id;
 this.neighbors = new ArrayList&lt;&gt;();
 }

 public void addNeighbor(int e) {
 this.neighbors.add(e);
 }

 public int getId() {
 return id;
 }

 public List&lt;Integer&gt; getNeighbors() {
 return neighbors;
 }

 @Override
 public String toString() {
 return &quot;Node{&quot; +
 &quot;id=&quot; + id +
 &quot;, neighbors=&quot; + neighbors +
 &quot;}&quot;+ &quot;\n&quot;;
 }
}
</code></pre>
This class is quite simple as well - just a constructor and a list of neighboring nodes.
With both of our classes, let's instantiate a graph and populate it with a few nodes:
<pre><code class="hljs">public class GraphInit {
 public static void main(String[] args) {
 Graph g = new Graph();
 Node node1 = new Node(1);
 Node node2 = new Node(2);
 Node node3 = new Node(3);
 Node node4 = new Node(4);
 node1.addNeighbor(2);
 node2.addNeighbor(3);
 node4.addNeighbor(3);
 g.addNode(node1);
 g.addNode(node2);
 g.addNode(node3);
 g.addNode(node4);
 System.out.println(g);
 }
}
</code></pre>
Output:
<pre><code class="hljs">Graph{nodes=[Node{id=1, neighbors=[2]}
, Node{id=2, neighbors=[3]}
, Node{id=3, neighbors=[]}
, Node{id=4, neighbors=[3]}
]}
</code></pre>
Now let's implement the algorithm itself:
<pre><code class="hljs">private static void topoSort(Graph g) {

 // Fetching the number of nodes in the graph
 int V = g.getSize();

 // List where we&#x27;ll be storing the topological order
 List&lt;Integer&gt; order = new ArrayList&lt;&gt; ();

 // Map which indicates if a node is visited (has been processed by the algorithm)
 Map&lt;Integer, Boolean&gt; visited = new HashMap&lt;&gt;();
 for (Node tmp: g.getNodes())
 visited.put(tmp.getId(), false);

 // We go through the nodes using black magic
 for (Node tmp: g.getNodes()) {
 if (!visited.get(tmp.getId()))
 blackMagic(g, tmp.getId(), visited, order);
 }

 // We reverse the order we constructed to get the
 // proper toposorting
 Collections.reverse(order);
 System.out.println(order);
}

private static void blackMagic(Graph g, int v, Map&lt;Integer, Boolean&gt; visited, List&lt;Integer&gt; order) {
 // Mark the current node as visited
 visited.replace(v, true);
 Integer i;

 // We reuse the algorithm on all adjacent nodes to the current node
 for (Integer neighborId: g.getNode(v).getNeighbors()) {
 if (!visited.get(neighborId))
 blackMagic(g, neighborId, visited, order);
 }

 // Put the current node in the array
 order.add(v);
}
</code></pre>
If we call <code>topoSort(g)</code> for the graph initialized above, we get the following output:
<pre><code class="hljs">[4, 1, 2, 3]
</code></pre>
Which is exactly right.
<h2 id="problemmodelingusingtopologicalsorting">Problem Modeling Using Topological Sorting</h2>
In a real-world scenario, topological sorting can be utilized to write proper assembly instructions for Lego toys, cars, and buildings.
There's actually a type of topological sorting which is used daily (or hourly) by most developers, albeit implicitly. If you're thinking Makefile or just Program dependencies, you'd be absolutely correct.
A typical Makefile looks like this:
<pre><code class="hljs">area_51_invasion.out: me.c, the_boys.c, Chads.c, Karen.c, the_manager.c
 #instructions for assembly when one of the files in the dependency list is modified
</code></pre>
With this line, we define which files depend on other files, or rather, we are defining in which topological order should the files be inspected to see if a rebuild is needed.
That is, if <code>area_51_invasion.out</code> depends on <code>the_boys.c</code> and <code>the_boys.c</code> is for some reason modified, we need to rebuild <code>area_51_invasion.out</code> and everything that depends on that same file, that is everything that comes before it in the Makefile's topological order.
<h2 id="conclusion">Conclusion</h2>
Considering <code>toposort()</code> is basically something we do on a regular basis. You may have even implemented it in your software and didn't even know it. And if you haven't, I strongly suggest you give it a whirl!