Dhananjay Singh

Spring Cloud: Contract

One of the many benefits of using version control software like Git is how easily you can copy the entire contents and history of a project with a simple command in your terminal. Once on your local machine, you can then make the changes/additions/deletions that you want, and <a target="_blank" href="/git-push-local-branch-and-track-it/">push</a> it back to the origin repo.
In this short article we'll see how you can clone a Git repository from a remote (or local) source.
<h2 id="cloningrepositories">Cloning Repositories</h2>
In order to clone a remote repository you'll want to use the <code>git clone</code> command, which is typically used in this fashion:
<pre><code class="hljs">$ git clone &lt;repo-url&gt;
</code></pre>
This will clone the repository in to your current working directory using the name of the repo as the destination directory. In order to clone it in to a different directory, you can specify one as the second parameter to <code>clone</code>:
<pre><code class="hljs">$ git clone &lt;repo-url&gt; &lt;directory&gt;
</code></pre>
An example of this command for a public GitHub repo would look like the following:
<pre><code class="hljs">$ git clone git@github.com:scottwrobinson/twentyjs.git twentyjs-clone
Cloning into &#x27;twentyjs-clone&#x27;...
remote: Enumerating objects: 48, done.
remote: Total 48 (delta 0), reused 0 (delta 0), pack-reused 48
Receiving objects: 100% (48/48), 9.35 KiB | 0 bytes/s, done.
Resolving deltas: 100% (22/22), done.
</code></pre>
Like all Git commands, there are quite a few flags that can be used here. Below are some of the more commonly used ones for <code>git clone</code>:
<ul>
<li><code>-l</code> or <code>--local</code>: This tells Git that the repo we're cloning is on our local machine, which bypasses the normal &quot;git aware&quot; transport mechanism. The files under <code>.git/objects/</code> are also hard-linked to the original repo, which saves disk space. This flag is unnecessary if the repo is specified as a local path, but must be explicitly specified if the local repo is specified as a URL.</li>
<li><code>--no-tags</code>: Do not download any of the repo's tags. This setting is also saved so that subsequent <code>git pull</code> and <code>git fetch</code> calls do not download tags.</li>
<li><code>-o &lt;name&gt;</code> or <code>--origin &lt;name&gt;</code>: Rename the remote repository for this clone from &quot;origin&quot; to whatever is specified by <code>&lt;name&gt;</code>.</li>
<li><code>-n</code> or <code>--no-checkout</code>: Don't check out HEAD after cloning</li>
<li><code>--bare</code>: Places the files from <code>&lt;directory&gt;/.git</code> directly in to the location specified by <code>&lt;directory&gt;</code>. This is good for when you need a copy of the repo, but you don't need to work directly out of it for development purposes.</li>
</ul>
Remember, I've only mentioned the most commonly used flags specific to the <code>clone</code> command. There are quite a few more, which you can check out using the <code>git help clone</code> command in your terminal.
<h2 id="cloninglocalrepositories">Cloning Local Repositories</h2>
As you've probably guessed from some of the flags mentioned above, you can also clone repositories that are already on your local machine. This is done by specifying the repo's directory path instead of a URL. Here is an example of what that would look like:
<pre><code class="hljs">$ git clone /Users/scott/sandbox/twentyjs /Users/scott/projects/twentyjs
</code></pre>
With this command the <code>twentyjs</code> Git project would be copied in to the new <code>projects/twentyjs</code> directory. You can ommit the destination path, but keep in mind that you either need to be in a different working directory than where it resides or you need to give it a different name to avoid conflicts.
<h2 id="otherprotocols">Other Protocols</h2>
There are a number of ways to specify which repository you want to clone, wheter you're cloning a local or remote repo. The differences are in the protocol you specify, which also must be supported by the server hosting the repo. When choosing a protocol, be sure to consider security requirements and use the most secure protocols when necessary or able.
A few examples of protocols that are natively supported by Git are shown below:
<ul>
<li><code>git://example.com[:port]/path/to/repo/project.git</code></li>
<li><code>ssh://[user@]example.com[:port]/path/to/repo/project.git</code></li>
<li><code>http[s]://example.com[:port]/path/to/repo/project.git</code></li>
<li><code>ftp[s]://example.com[:port]/path/to/repo/project.git</code> (not recommended due to deprecation)</li>
</ul>
Other URL forms are also supported, depending on the protocol being used, like this one for SSH:
<ul>
<li><code>user@example.com:path/to/repo/project.git</code></li>
</ul>
As for local repositories, you can use one of the following forms:
<ul>
<li><code>/path/to/repo/project.git</code></li>
<li><code>file:///path/to/repo/project.git</code></li>
</ul>

Scott Robinson

Git: Clone a Repository

Olivera Popović

Java Flow Control: for and for-each Loops

<h2 id="introduction">Introduction</h2>
Object detection is a technology that falls under the broader domain of <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Computer_vision">Computer Vision</a>. It deals with identifying and tracking objects present in images and videos. Object detection has multiple applications such as face detection, vehicle detection, pedestrian counting, self-driving cars, security systems, etc.
The two major objectives of object detection include:
<ul>
<li>To identify all objects present in an image</li>
<li>Filter out the object of attention</li>
</ul>
In this article, you will see how to perform object detection in Python with the help of the <a rel="nofollow" target="_blank" href="https://imageai.readthedocs.io/en/latest/detection/index.html">ImageAI</a> library.
<h2 id="deeplearningforobjectdetection">Deep Learning for Object Detection</h2>
Deep learning techniques have been proven state of the art for various object detection problems. The following are some of the commonly used deep learning approaches for object detection:
<ul>
<li>ImageAI</li>
<li><a rel="nofollow" target="_blank" href="https://leonardoaraujosantos.gitbooks.io/artificial-inteligence/content/single-shot-detectors.html">Single Shot Detectors</a></li>
<li><a rel="nofollow" target="_blank" href="https://appsilon.com/object-detection-yolo-algorithm/">YOLO (You only look once)</a></li>
<li><a rel="nofollow" target="_blank" href="https://leonardoaraujosantos.gitbooks.io/artificial-inteligence/content/single-shot-detectors.html">Region-based Convolutional Neural Networks</a></li>
</ul>
In the rest of this article, we will see what exactly ImageAI is and how to use it to perform object detection.
<h2 id="imageai">ImageAI</h2>
ImageAI is a Python library built to empower developers to build applications and systems with self-contained deep learning and Computer Vision capabilities using a few lines of straight forward code. ImageAI contains a Python implementation of almost all of the state-of-the-art deep learning algorithms like <a rel="nofollow" target="_blank" href="https://arxiv.org/abs/1708.02002">RetinaNet</a>, <a rel="nofollow" target="_blank" href="https://pjreddie.com/darknet/yolo/">YOLOv3</a>, and TinyYOLOv3.
ImageAI makes use of several APIs that work offline - it has object detection, video detection, and object tracking APIs that can be called without internet access. ImageAI makes use of a pre-trained model and can easily be customized.
The <code>ObjectDetection</code> class of the ImageAI library contains functions to perform object detection on any image or set of images, using pre-trained models. With ImageAI, you can detect and recognize 80 different kinds of common, everyday objects.
<h3 id="settingupyourenvironment">Setting up your Environment</h3>
In this part of the tutorial, we will work through the installation of ImageAI.
To use ImageAI you need to install a few dependencies. The first step is to have Python installed on your computer. Download and install Python 3 from the <a rel="nofollow" target="_blank" href="https://www.python.org/">official Python website</a>.
Once you have Python installed on your computer, install the following dependencies using <code>pip</code>:
TensorFlow
<pre><code class="hljs">$ pip install tensorflow
</code></pre>
OpenCV
<pre><code class="hljs">$ pip install opencv-python
</code></pre>
Keras
<pre><code class="hljs">$ pip install keras
</code></pre>
ImageAI
<pre><code class="hljs">$ pip install imageAI
</code></pre>
Now download the <a rel="nofollow" target="_blank" href="https://github.com/OlafenwaMoses/ImageAI/releases/download/1.0/yolo-tiny.h5">TinyYOLOv3</a> model file that contains the classification model that will be used for object detection.
<h3 id="performingobjectdetectionwithimageai">Performing Object Detection with ImageAI</h3>
Now let's see how to actually use the ImageAI library. I'll explain step by step how you can build your first object detection model with ImageAI.
<h4 id="step1">Step 1</h4>
Our first task here is to create the necessary folders. For this tutorial we need the following folders:
<ul>
<li>Object detection: root folder</li>
<li>models: stores pre-trained model</li>
<li>input: stores image file on which we want to perform object detection</li>
<li>output: stores image file with detected objects</li>
</ul>
After you have created your folders, your <code>Object detection</code> folder should have the following sub-folders:
<pre><code class="hljs">├── input
├── models
└── output

3 directories, 0 files
</code></pre>
<h4 id="step2">Step 2</h4>
Open your preferred text editor for writing Python code and create a new file <code>detector.py</code>.
<h4 id="step3">Step 3</h4>
Import <code>ObjectDetection</code> class from the ImageAI library.
<pre><code class="hljs">from imageai.Detection import ObjectDetection
</code></pre>
<h4 id="step4">Step 4</h4>
Now that you have imported imageAI library and the <code>ObjectDetection</code> class , the next thing is to create an instance of the class <code>ObjectDetection</code>, as shown here:
<pre><code class="hljs">detector = ObjectDetection()
</code></pre>
<h4 id="step5">Step 5</h4>
Let's specify the path from our input image, output image, and model.
<pre><code class="hljs">model_path = &quot;./models/yolo-tiny.h5&quot;
input_path = &quot;./input/test45.jpg&quot;
output_path = &quot;./output/newimage.jpg&quot;
</code></pre>
<h4 id="step6">Step 6</h4>
After instantiating the <code>ObjectDetection</code> class we can now call various functions from the class. The class contains the following functions to call pre-trained models: <code>setModelTypeAsRetinaNet()</code>, <code>setModelTypeAsYOLOv3()</code>, and <code>setModelTypeAsTinyYOLOv3()</code>.
For the purpose of this tutorial, I'll be using the pre-trained <code>TinyYOLOv3</code> model, and hence we will use the <code>setModelTypeAsTinyYOLOv3()</code> function to load our model.
<pre><code class="hljs">detector.setModelTypeAsTinyYOLOv3()
</code></pre>
<h4 id="step7">Step 7</h4>
Next, we are going to call the function <code>setModelPath()</code>. This function accepts a string which contains the path to the pre-trained model:
<pre><code class="hljs">detector.setModelPath(model_path)
</code></pre>
<h4 id="step8">Step 8</h4>
This step calls the function <code>loadModel()</code> from the <code>detector</code> instance. It loads the model from the path specified above using the <code>setModelPath()</code> class method.
<pre><code class="hljs">detector.loadModel()
</code></pre>
<h4 id="step9">Step 9</h4>
To detect objects in the image, we need to call the <code>detectObjectsFromImage</code> function using the <code>detector</code> object that we created in the previous section.
This function requires two arguments: <code>input_image</code> and <code>output_image_path</code>. <code>input_image</code> is the path where the image we are detecting is located, while the <code>output_image_path</code> parameter is the path to store the image with detected objects. This function returns a dictionary which contains the names and percentage probabilities of all the objects detected in the image.
<pre><code class="hljs">detection = detector.detectObjectsFromImage(input_image=input_path, output_image_path=output_path)
</code></pre>
<h4 id="step10">Step 10</h4>
The dictionary items can be accessed by traversing through each item in the dictionary.
<pre><code class="hljs">for eachItem in detection:
 print(eachItem[&quot;name&quot;] , &quot; : &quot;, eachItem[&quot;percentage_probability&quot;])
</code></pre>
<h4 id="completecodeforobjectdetection">Complete Code for Object Detection</h4>
Here is the complete code for the image detection:
<pre><code class="hljs">from imageai.Detection import ObjectDetection

detector = ObjectDetection()

model_path = &quot;./models/yolo-tiny.h5&quot;
input_path = &quot;./input/test45.jpg&quot;
output_path = &quot;./output/newimage.jpg&quot;

detector.setModelTypeAsTinyYOLOv3()
detector.setModelPath(model_path)
detector.loadModel()
detection = detector.detectObjectsFromImage(input_image=input_path, output_image_path=output_path)

for eachItem in detection:
 print(eachItem[&quot;name&quot;] , &quot; : &quot;, eachItem[&quot;percentage_probability&quot;])
</code></pre>
In the output, you can see the name of each detected object along with its percentage probability as shown below: 
Output
<pre><code class="hljs">car : 54.72719073295593
car : 58.94589424133301
car : 62.59384751319885
car : 74.07448291778564
car : 91.10507369041443
car : 97.26507663726807
car : 97.55765795707703
person : 53.6459743976593
person : 56.59831762313843
person : 72.28181958198547
</code></pre>
Original image:
The original image, i.e. &quot;test45&quot;, looked like this:
<img src="https://stackabuse.s3.amazonaws.com/media/object-detection-with-imageai-python-1.jpg" alt="">
Image with Object Detection:
After the object detection, the resulting image looks like this:
<img src="https://stackabuse.s3.amazonaws.com/media/object-detection-with-imageai-python-2.jpg" alt="">
You can see that ImageAI has successfully identified cars and persons in the image.
<h2 id="conclusion">Conclusion</h2>
Object detection is one of the most common computer vision tasks. This article explains how to perform object detection in Python using the ImageAI library with the help of an example.
References
<ul>
<li><a rel="nofollow" target="_blank" href="https://imageai.readthedocs.io/en/latest/detection/index.html">https://imageai.readthedocs.io/en/latest/detection/index.html</a></li>
</ul>

Guest Contributor

Object Detection with ImageAI in Python

Usman Malik

Python for NLP: Working with Facebook FastText Library

<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="while">while</h2>
A loop is a set of instructions that are repeatedly executed until some condition is met, or alternatively as long as a condition is <code>true</code>. The <code>while</code> loop in Java works on the latter principle, it repeats a block of code as long as the condition evaluates to <code>true</code>:
<pre><code class="hljs">while(condition) {
 // Block of code to be executed
}
</code></pre>
When Java encounters a <code>while</code> loop it does the following:
<ul>
<li>Is the <code>condition</code> true?
<ul>
<li>Yes -&gt; execute the block of code. Check the condition again.</li>
<li>No -&gt; don't execute the block of code. Don't check the condition again.</li>
</ul>
</li>
</ul>
This means that if we had a statement like <code>while(true)</code>, the block of code would execute indefinitely (or at least, try to). This is called an infinite loop and is to be avoided unless we have a way of breaking out of the loop - typically with a <code>break</code> statement.
The <code>condition</code> can be any type of <code>Boolean</code> expression, the same as with <code>if</code> statements.
Since <code>while</code> checks the <code>condition</code> before executing any code, it is possible that the block of code within the while loop is never executed if the <code>condition</code> was <code>false</code> at the beginning.
This is different from a <code>for</code> loop, which typically executes a set number of times. <code>while</code> loops, on the other hand, are often used to execute an unknown number of times.
Here's an example of a <code>while</code> loop that sums up all the digits of an <code>int</code>.
<pre><code class="hljs">int n = 123;
int sumOfDigits = 0;

while(n &gt; 0) {
 int lastDigit = n % 10; // Retrieves the last digit of n via the modulus operator
 n = n / 10; // &quot;Removes&quot; the last digit from n via division

 sumOfDigits += lastDigit; // Adds the current digit to the sum
}

System.out.println(sumOfDigits);
</code></pre>
The execution of this code works in the following way:
<ul>
<li>The while condition is checked, <code>n</code> is 123 and <code>sumOfDigits</code> is 0. Is <code>n &gt; 0</code> equal to <code>true</code>? Yes -&gt; execute the code in the loop.</li>
<li>The while condition is checked, <code>n</code> is 12 and <code>sumOfDigits</code> is 3. Is <code>n &gt; 0</code> equal to <code>true</code>? Yes -&gt; execute the code in the loop.</li>
<li>The while condition is checked, <code>n</code> is 1 and <code>sumOfDigits</code> is 5. Is <code>n &gt; 0</code> equal to <code>true</code>? Yes -&gt; execute the code in the loop.</li>
<li>The while condition is checked, <code>n</code> is 0 and <code>sumOfDigits</code> is 6. Is <code>n &gt; 0</code> equal to <code>true</code>? No -&gt; execute the first line after the loop, in our case print out the result.</li>
</ul>
After executing the while loop 3 times, a value of 6 is printed to the console.
The body of the while loop can be empty, and sometimes developers like to write shorthand <code>while</code> loops when possible. Additionally, the same rule of shortening <code>if</code> and <code>else</code> statements applies to <code>while</code>. So a single-line <code>while</code> loop can be re-written without the brackets, like this:
<pre><code class="hljs">// This...
while(i &lt; j) {
 System.out.println(&quot;i &quot; + i++ + &quot; j &quot; + j--);
}

// ...becomes this:
while(i &lt; j)
 System.out.println(&quot;i &quot; + i++ + &quot; j &quot; + j--);
</code></pre>
Also notice that the variables used in the checked condition can be changed either within the <code>while</code> loops code block or within the checked condition itself:
<pre><code class="hljs">while(++i &lt; --j)
 System.out.println(&quot;i &quot; + i + &quot; j &quot; + j);
</code></pre>
Both of these result in the same output:
<pre><code class="hljs">i 1 j 9
i 2 j 8
i 3 j 7
i 4 j 6
</code></pre>
However, they may reduce readability and should be avoided if they do.
<h2 id="dowhile">do-while</h2>
This loop does essentially the same thing as <code>while</code>, but it guarantees that the block of code will be executed at least once.
This is because, unlike in <code>while</code>, the code is executed before the condition is checked. So even if we start off with a <code>false</code> condition, it'll execute the code and then check if it should do it again:
<pre><code class="hljs">int i = 0;

// This will print once
do {
 System.out.println(i);
 i--;
} while(i &gt; 0);
</code></pre>
The output of the code is:
<pre><code class="hljs">0
</code></pre>
After the code reaches <code>while(i &gt; 0)</code>, it stops the iterations.
For example, one use-case for <code>do-while</code> is to ask the user if they want to try doing something again in case it fails.
<pre><code class="hljs">do {
 // Try to connect to a server, access a resource, etc...
 String status = connectToServer();

 // Ask user whether they want to try again
 String userInput = getUserInput(&quot;Connection status is &quot; + status + &quot;. Want to try again?&quot;);
} while(userInput == &quot;yes&quot;);
</code></pre>
This can be done with a regular <code>while</code> loop, but it's more readable and intuitive this way.
<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.
<code>while</code> and <code>do-while</code> loops are good for executing a block of code an unknown number of times, where a condition is checked every time the code block re-runs.

Java Flow Control: while and do-while Statements

<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.

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.