<h2 id="introduction">Introduction</h2>
Servers are computer software or hardware that processes requests and delivers data to a client over a network. Various types of servers exist, with the most common ones being web servers, database servers, application servers, and transaction servers.
Widely used web servers such as <a rel="nofollow" target="_blank" href="https://www.apache.org/">Apache</a>, <a rel="nofollow" target="_blank" href="http://monkey-project.com/">Monkey</a>, and <a rel="nofollow" target="_blank" href="https://jigsaw.w3.org/">Jigsaw</a> are quite time-consuming to set up when testing out simple projects and a developer's focus is shifted from producing application logic to setting up a server.
Python's <code>SimpleHTTPServer</code> module is a useful and straightforward tool that developers can use for a number of use-cases, with the main one being that it is a quick way to serve files from a directory.
It eliminates the laborious process associated with installing and implementing the available cross-platform web servers.
Note: While <code>SimpleHTTPServer</code> is a great way to easily serve files from a directory, it shouldn't be used in a production environment. According to the official Python docs, it &quot;only implements basic security checks.&quot;
<h2 id="whatisanhttpserver">What is an HTTP Server</h2>
HTTP stands for HyperText Transfer Protocol. Let us think of a protocol as a spoken language like English. English has a set of rules and vocabulary. Thus, if we both understand the rules and vocabulary defining the English Language, then we can communicate in the language effectively.
Just like human beings, electronic devices communicate with each other as well. They, therefore, need a 'set of rules and vocabulary' to actively pass and receive information from each other.
A protocol is a standard set of rules that facilitates successful communication between electronic devices. These sets of mutually accepted and implemented rules include the commands used to initiate the sending and reception of data, the data types to be transmitted between devices, how to detect errors in data, how successful data transfers are confirmed, and much more.
For example, when you perform a simple search using a browser, there were two essential systems involved - the HTTP Client and HTTP Server.
The client, commonly referred to as the browser, can be an elaborate program such as Google Chrome, or Firefox, but it can also be as simple as a CLI application. The client sends your request to the server, which the processes the HTTP requests and provides a response to the client. In the case of browsers, the response is typically an HTML page.
<h2 id="pythonssimplehttpservermodule">Python's SimpleHTTPServer Module</h2>
When you need a quick web server running, setting up a production-level server is a massive overkill.
Python's <code>SimpleHTTPServer</code> module is a labor-saving tool that you can leverage for turning any directory in your system into an uncomplicated web server. It comes packaged with a simple HTTP server that delivers standard <code>GET</code> and <code>HEAD</code> request handlers.
With a built-in HTTP server, you are not required to install or configure anything to have your web server up and running.
Note: The Python <code>SimpleHTTPServer</code> module was merged into the <code>http.server</code> module in Python 3. Throughout this article we'll be using the Python 3 version, but if you're using Python 2 you can swap out <code>http.server</code> for <code>SimpleHTTPServer</code> and it should work in most cases.
<h2 id="commandlineusage">Command Line Usage</h2>
The simplest way to start up a web server that serves the directory in which the command is ran is to simply navigate to your project's directory using the terminal and run:
Python 2
<pre><code class="hljs">$ python -m SimpleHTTPServer 8000
</code></pre>
Python 3
<pre><code class="hljs">$ python3 -m http.server 8000
</code></pre>
By running this command, you'll be able to access the files in your directory through your browser at <code>localhost:8000</code>:
<img src="https://stackabuse.s3.amazonaws.com/media/serving-files-with-pythons-simplehttpserver-module-1.png" alt="application directory listing">
As you can see, the server provides a simple directory UI in which you can access any of the files. This is the simplest way to directly serve files locally over HTTP.
<h2 id="defaultpythonusage">Default Python Usage</h2>
For one reason or another, running this server via the command line might not suit our use-case. At times like this we can instead use the server directly in our code using the <code>SimpleHTTPRequestHandler</code> object. But first, we need to set it up with a socket server.
Beneath the HTTP protocol are UDP (User Datagram Protocol) or TCP (Transmission Control Protocol), which are transport protocols that handle the transportation of data from one network location to another. Since we're running an HTTP server, our application will use the TCP protocol, through a TCP Socket Address which contains an IP address and a port number. This can be set up with Python's <code>socketserver.TCPServer</code>, which we've implemented below:
<pre><code class="hljs">import http.server
import socketserver

PORT = 8000

handler = http.server.SimpleHTTPRequestHandler

with socketserver.TCPServer((&quot;&quot;, PORT), handler) as httpd:
 print(&quot;Server started at localhost:&quot; + str(PORT))
 httpd.serve_forever()
</code></pre>
Note: The code will fail with the error <code>AttributeError: __exit__</code> for Python versions &lt; 3.6. This is because in previous versions <code>socketserver.TCPServer</code> does not support use with <a target="_blank" href="/python-context-managers/">context managers</a> (the <code>with</code> keyword). In these cases you need to call <code>server_close()</code> to stop the server.
By default, the <code>SimpleHTTPRequestHandler</code> serves files from the current directory and related subdirectories. As the name suggests, it is a simple HTTP request handler. Being the simple server that it is, it only allows you to retrieve data and not post it to the server. And because of this, it only implements the HTTP <code>GET</code> and <code>HEAD</code> methods via <code>do_GET()</code> and <code>do_HEAD()</code>.
The parameters passed to the <code>TCPServer</code> represent the IP address and port number. By leaving the IP address empty, the server listens to all available IP addresses, while we've set the port to <code>8000</code>. This means that it would then be accessible on <code>localhost:8000</code>.
Finally, <code>httpd.server_forever()</code> starts the server, listens, and responds to incoming requests from the client.
The server can be started by simply executing the file:
<pre><code class="hljs">$ python3 simple-server.py
</code></pre>
And just like with the command line usage, we can now access the directory through our web browser:
<img src="https://stackabuse.s3.amazonaws.com/media/serving-files-with-pythons-simplehttpserver-module-1.png" alt="application directory listing">
<h2 id="customizingpaths">Customizing Paths</h2>
Another approach we can take is to make a custom class that extends <code>SimpleHTTPRequestHandler</code> and handles our requests with some custom functionality. To do this, we implement our own <code>do_GET()</code> function.
But before we get to that, let's say we have an HTML file that we want to serve, <code>mywebpage.html</code>:
<pre><code class="hljs">&lt;!DOCTYPE html&gt;
&lt;html&gt;
&lt;head&gt;
 &lt;title&gt;Using Python&#x27;s SimpleHTTPServer Module&lt;/title&gt;
 &lt;style&gt;
 #rectangle {
 height: 50px;
 width: 100px;
 background-color: #00f28f;
 }
 &lt;/style&gt;
&lt;/head&gt;
&lt;body&gt;
 &lt;h2&gt;Rectangle served by SimpleHTTPServer&lt;/h2&gt;
 &lt;div id=&quot;rectangle&quot;&gt;&lt;/div&gt;
&lt;/body&gt;
&lt;/html&gt;
</code></pre>
In order to serve this HTML from a path that isn't <code>/mywebpage.html</code>, we can use our custom handler to serve it on any path we want. In this example we'll just serve it on the root path, <code>/</code>:
<pre><code class="hljs">import http.server
import socketserver

class MyHttpRequestHandler(http.server.SimpleHTTPRequestHandler):
 def do_GET(self):
 if self.path == &#x27;/&#x27;:
 self.path = &#x27;mywebpage.html&#x27;
 return http.server.SimpleHTTPRequestHandler.do_GET(self)

# Create an object of the above class
handler_object = MyHttpRequestHandler

PORT = 8000
my_server = socketserver.TCPServer((&quot;&quot;, PORT), handler_object)

# Star the server
my_server.serve_forever()
</code></pre>
Again, running this script will allow us to access it through the browser:
<img src="https://stackabuse.s3.amazonaws.com/media/serving-files-with-pythons-simplehttpserver-module-2.png" alt="rectangle served on the browser">
Though, there are a lot more customizations we can do with the response via the <code>self</code> reference, which we'll see in the next section.
<h2 id="returningdynamichtml">Returning Dynamic HTML</h2>
A common usage of web servers is to serve dynamically generated HTML. Although this is only a very simple server, it can perform this task as well. In addition to sending dynamic HTML, we can also set different status codes, headers, etc. In the following example we set some headers and return dynamic HTML that is generated using the query parameter <code>name</code>:
<pre><code class="hljs">import http.server
import socketserver
from urllib.parse import urlparse
from urllib.parse import parse_qs

class MyHttpRequestHandler(http.server.SimpleHTTPRequestHandler):
 def do_GET(self):
 # Sending an &#x27;200 OK&#x27; response
 self.send_response(200)

 # Setting the header
 self.send_header(&quot;Content-type&quot;, &quot;text/html&quot;)

 # Whenever using &#x27;send_header&#x27;, you also have to call &#x27;end_headers&#x27;
 self.end_headers()

 # Extract query param
 name = &#x27;World&#x27;
 query_components = parse_qs(urlparse(self.path).query)
 if &#x27;name&#x27; in query_components:
 name = query_components[&quot;name&quot;][0]

 # Some custom HTML code, possibly generated by another function
 html = f&quot;&lt;html&gt;&lt;head&gt;&lt;/head&gt;&lt;body&gt;&lt;h1&gt;Hello {name}!&lt;/h1&gt;&lt;/body&gt;&lt;/html&gt;&quot;

 # Writing the HTML contents with UTF-8
 self.wfile.write(bytes(html, &quot;utf8&quot;))

 return

# Create an object of the above class
handler_object = MyHttpRequestHandler

PORT = 8000
my_server = socketserver.TCPServer((&quot;&quot;, PORT), handler_object)

# Star the server
my_server.serve_forever()
</code></pre>
And running this code with the URL <code>http://localhost:8000?name=Billy</code> will yield:
<img src="https://stackabuse.s3.amazonaws.com/media/serving-files-with-pythons-simplehttpserver-module-3.png" alt="serving dynamic html">
Any value you set for the <code>name</code> query parameter will then show up on the screen! You can even omit the <code>name</code> query parameter and see what happens.
As you can see, creating a custom request handler allows us to manipulate the responses as much as we'd like by changing the implementation of the <code>do_GET</code> method and we don't have such control over our responses with the default implementation.
The same can be done with the HTTP HEAD method (via the <code>do_HEAD()</code> function), but since it is very similar to that of GET method we'll leave that as an exercise to the reader.
<h2 id="conclusion">Conclusion</h2>
Python provides us with the <code>SimpleHTTPServer</code> module (or <code>http.server</code> in Python 3) that can be used to quickly and easily serve files from a local directory via HTTP. This can be used for many development or other internal tasks, but is not meant for production.
This is a great solution for local use since web servers such as <a rel="nofollow" target="_blank" href="https://www.apache.org/">Apache</a>, <a rel="nofollow" target="_blank" href="http://monkey-project.com/">Monkey</a>, and <a rel="nofollow" target="_blank" href="https://jigsaw.w3.org/">Jigsaw</a> are much more difficult to get set up and are often overkill for development activities.

Guest Contributor

For quick testing, setting up a server is more of a hassle than making the application itself. In this article, we'll use the SimpleHTTPServer module to quickly run a Python app and access it through the browser.

Serving Files with Python's SimpleHTTPServer Module

<h2 id="introduction">Introduction</h2>
A list is one of the fundamental data types in Python. Every time you come across a variable name that's followed by a square bracket <code>[]</code>, or a <code>list</code> constructor, it is a list capable of containing multiple items, making it a compound data type. Similarly, it is also a breeze to declare a new list and subsequently, add one or more items to it.
<h2 id="shortoverviewoflistsinpython">Short Overview of Lists in Python</h2>
Let us create a new populated list:
<pre><code class="hljs">new_list = [1, 2, 3, 4, 5]
print(new_list) # [1, 2, 3, 4, 5]
</code></pre>
Or we can simply use the <code>append()</code> method to add anything you want to the list:
<pre><code class="hljs">new_list.append(6)
print(new_list) # [1, 2, 3, 4, 5, 6]
</code></pre>
If you need to append multiple items to the same list, the <code>extend()</code> method will come in handy. You simply need to pass the list of items to append to the <code>extend</code> method, as shown below:
<pre><code class="hljs">new_list.extend([7, 8, 9])
print(new_list) # [1, 2, 3, 4, 5, 6, 7, 8, 9]
</code></pre>
As you can see, creating a list and appending it with other items is just a piece of cake. You can accomplish this task without having to make multiple calls to the <code>.append()</code> method.
Similarly, you can use a <code>for</code> loop to append multiple items to a list. For example, we will have to write the following piece of code for creating a list of squares for the integers 1-20.
<pre><code class="hljs">list_a = []
for i in range(1, 20):
 list_a.append(i**2)
</code></pre>
<h2 id="whatarelistcomprehensionsinpython">What are List Comprehensions in Python?</h2>
In the simplest of words, list comprehension is the process of creating a new list from an existing list. Or, you can say that it is Python's unique way of appending a <code>for</code> loop to a list. But, it is already pretty simple to declare a list and append anything you like to it. Isn't it? So, why bother comprehending our lists?
List comprehension, in fact, offers many benefits over traditional lists. To begin with, the code spans over only a single line, making it even easier to declare and read. It is also less cumbersome to comprehend lists than using <code>for</code> loops to declare a new one. Finally, it is also a convenient, quicker, and intuitive way of generating a new, populated list.
Going back to the squares of the integers 1-20, we can obtain the same result using the list comprehension method. Here is what our code will look like now:
<pre><code class="hljs">list_b = [i**2 for i in range(1, 20)]
</code></pre>
Notice how the logic for generating the list items is all wrapped in brackets. We'll cover more about the syntax in the next section.
<h2 id="listcomprehensionssyntax">List Comprehensions Syntax</h2>
Before we move forward, it is imperative to explain the syntax of list comprehension. Here is the basic syntax of list comprehension that contains a condition:
<pre><code class="hljs">[expression for item in list if conditional]
</code></pre>
It may seem a bit backward with the <code>expression</code> being before the loop, but this is how it's done! The order is this way, presumably, because it would be difficult to put the <code>expression</code> after the <code>conditional</code> without some type of semicolon, which Python doesn't have.
As you might have already guessed, <code>expression</code> is actually the output we get when we execute the rest of the code in a list comprehension. The code itself is just a for loop iterating over a collection of data. In our example, we are using the <code>expression</code>, or the output, to generate the list of squares.
Note that the conditional is optional, so like in our example above we don't need to include it.
It is also worth mentioning that we have a list to be looped over, the item or items to be iterated, and of course a conditional statement in both the list comprehension and traditional for loops. So each method has the same general constructs, but the difference is how you format and organize them.
We are also going to look at another, more complex example to further understand the concept behind list comprehension.
<pre><code class="hljs">list_a = [1, 3, 6, 9, 12, 15]
list_b = []
for number in list_a:
 if number % 4 == 0:
 list_b.append(number)

print(list_b)
</code></pre>
We are actually looping over the <code>list_a</code> in the above example. Subsequently, we will append an item to <code>list_b</code> if its value is divisible by 4, which is checked using the modulus operator (<code>%</code>). In this example we'd see the following printed to the console:
<pre><code class="hljs">[12]
</code></pre>
This is because 12 is the only number in that array that is divisible by 4.
Once again, we can just use list comprehension to reduce the total lines of code we have to write to attain the same goal.
As mentioned above, the <code>for</code> loop in the above statement is iterating over the list called <code>list_a</code>. Then it executes the conditional statement that checks if the current value is divisible by 4. Finally, it executes the <code>.append()</code> method when it ascertains that the value is actually divisible by 4.
Now, if you want to write the above piece of code with list comprehension, it would look something like this:
<pre><code class="hljs">list_a = [1, 3, 6, 9, 12, 15]
list_b = [number for number in list_a if number % 4 == 0]

print(list_b)
</code></pre>
As you can see, we have reduced the <code>for</code> loop, which spanned over three lines, to only one line. That is actually the real beauty of list comprehension.
<h2 id="whentouselistcomprehensions">When to Use List Comprehensions</h2>
You can use list comprehension in many cases in which you need to generate a list from an iterable. However, the best time to use this method is when you need to add or extract items to a list consistently according to a set pattern. Python developers mostly use them to extract data from an often big collection of items.
Let us suppose you have a list of thousands of current and previous students with their names, their father's names, and addresses. The data of each of the students is further stored in a respective dictionary. But, what if you only want to print their names?
<pre><code class="hljs">students = [
 {
 &quot;name&quot; : &quot;Jacob Martin&quot;,
 &quot;father name&quot; : &quot;Ros Martin&quot;,
 &quot;Address&quot; : &quot;123 Hill Street&quot;,
 }, {
 &quot;name&quot; : &quot;Angela Stevens&quot;,
 &quot;father name&quot; : &quot;Robert Stevens&quot;,
 &quot;Address&quot; : &quot;3 Upper Street London&quot;,
 }, {
 &quot;name&quot; : &quot;Ricky Smart&quot;,
 &quot;father name&quot; : &quot;William Smart&quot;,
 &quot;Address&quot; : &quot;Unknown&quot;,
 }
]
</code></pre>
We do have the option to iterate over the list using the traditional <code>for</code> loop:
<pre><code class="hljs">names_list = []

for student in students:
 names_list.append(student[&#x27;name&#x27;])

print(names_list)
</code></pre>
Although in this example it's only two lines of code for the <code>for</code> loop, we don't even need to write this many lines. We can accomplish the same task by writing only one line of code through the list comprehension method:
<pre><code class="hljs">names_list = [student[&#x27;name&#x27;] for student in students]

print(names_list)
</code></pre>
<pre><code class="hljs">['Jacob Martin', 'Angela Stevens', 'Ricky Smart']
</code></pre>
<h2 id="conclusion">Conclusion</h2>
It is really amazing how list comprehensions actually reduces your workload as well. However, it may seem confusing in the beginning. It is particularly baffling for beginners who have never ventured into this territory before, mostly due to the syntax. You may also find it hard to grasp the concept if you have been programming in other languages because list comprehension does not exist in any of them. The only way to get your head around list comprehension is to practice hard.

Dimitrije Stamenic

List Comprehensions is the process of creating a new list from an existing one. They offer many benefits to traditional lists. In this article, we'll dive into the theory and practice of using list comprehensions.

List Comprehensions in Python

Usman Malik

Tensorflow 2.0 introduced some hefty new features. Amongst them, it now uses the Keras API by default for classification and regression. In this article, we'll take on these classic ML tasks using Tensorflow 2.0.

Tensorflow 2.0: Solving Classification and Regression Problems

Josh Simpson

AWS SNS is a scalable service that allows us to implement the publish/subscribe model with ease. In this tutorial, we'll build a Node.js application, subscribe to an SNS topic and push messages to the subscibers.

Publishing and Subscribing to AWS SNS Messages with Node.js

<h2 id="introduction">Introduction</h2>
Stochastic Optimization refers to a category of optimization algorithms that generate and utilize random points of data to find an approximate solution.
While brute-force algorithms do provide us with the best solution, they're terribly inefficient. This isn't an issue with smaller datasets, but most real-life problems and search-spaces require such a huge computational capability to be solved in a reasonable time-frame that such computers will likely exist beyond a predictable future.
In such cases, a new approach has to be used, and instead of searching for the actual best solution, we settle for an approximate solution that'll work good enough for us.
Many optimization methods exist, and each method can be implemented through many different algorithms. We'll start out by implementing the least efficient and most intuitive Stochastic Search algorithm - Random Search.
In pursuit of efficiency over absolute correctness, many random algorithms have been developed, culminating with evolutionary algorithms such as <a target="_blank" href="/introduction-to-genetic-algorithms-in-java/">Genetic Algorithms</a>.
<h2 id="randomsearch">Random Search</h2>
Random Search is the simplest stochastic search algorithm and it's very intuitive. For example, say we're searching for the maximum of a function. Instead of brute-forcing the solution, it generates random points on a dimension of the search space.
Then, it proceeds to check each of those points by comparing the current fmax against the value of the point it's on, assigning it a new value if necessary. After going through all the generated points, it returns us the fmax as the approximate solution.
The downside with all stochastic search algorithms, and especially Random Search, is that they can be as inefficient as brute-force algorithms if you don't balance it.
<blockquote>
The more random points you use, the closer the approximation will be to the absolute best solution, but the slower the algorithm will be. With an infinite amount of random points, it's just a regular brute-force algorithm.
</blockquote>
Here's a function generated by <a rel="nofollow" target="_blank" href="http://fooplot.com/">FooPlot</a> as an example of how Random Search searches for the maximum/minimum of a function:
<img src="https://stackabuse.s3.amazonaws.com/media/stochastic-optimization-random-search-in-java-1.PNG" alt="function">
There are 7 randomly generated points here, where coincidentally the point 7 is located at the x value that will return the lowest y value and 5 is close to the value that will return the highest y value, for an example.
We'll limit the domain of the function to range from <code>-1</code> to <code>2</code> and in that range, using simple high school calculus, it's easy to deduce that:
$$ 
f_{max} = (0.73947, 0.23098) \wedge f_{min} = (1.71548, -2.79090) 
$$
That being said, depending on the specific accuracy you're looking for (95% for example), if Random Search approximates anything between <code>(0.7, 0.2)</code> and <code>(0.75, 0.25)</code> for the fmax and <code>(1.65, -2.65)</code> and <code>(1.8, -2.9)</code> for the fmin should be an approximately good solution.
<h3 id="implementation">Implementation</h3>
Let's go ahead and implement Random Search in Java. First, let's bound the domain of our function to <code>{-1...2}</code>:
<pre><code class="hljs">private static final double START_DOMAIN = -1;
private static final double END_DOMAIN = 2;
</code></pre>
Then, let's replicate the function from FooPlot, which of course, returns <code>y</code> based on <code>x</code>:
<pre><code class="hljs">private double function(double x) {
 return ((Math.pow(x, 2)-1)*((x-2)*Math.pow(x, 3)));
}
</code></pre>
Finally, let's implement the algorithm itself:
<pre><code class="hljs">public void randomSearch() {
 double startPosition = START_DOMAIN;
 double maxY = function(startPosition);
 double maxX = START_DOMAIN;

 for (int i = 0; i &lt; 10; i++) {
 double random = ThreadLocalRandom.current().nextDouble(START_DOMAIN, END_DOMAIN);

 if (function(random) &gt; maxY) {
 maxY = function(random);
 maxX = random;
 }
 }

 System.out.println(&quot;The maximum of the function f(x) is (&quot; + maxX + &quot;, &quot; + maxY + &quot;)&quot;);
}
</code></pre>
The starting position for the iteration is obviously at the start of the domain. The <code>maxY</code> is calculated using the <code>function()</code> method we've defined and the <code>maxX</code> is set as the value at the start of the domain as well.
These are the current max values as we haven't evaluated anything else yet. As soon as we assign them the default values, through a <code>for</code> loop, we generate a random point between the start and the end of the domain. We then evaluate if the random point, passed through the <code>function()</code>, is by any change larger than the current <code>maxY</code>.
Note: We're using a <code>ThreadLocalRandom</code> instead of a regular <code>Random</code> since <code>ThreadLocalRandom</code> can work way faster than <code>Random</code> in a multi-threaded environment. In our case, it doesn't make much of a difference, but it can make a significant one. Also, it's easier to define a range of <code>double</code>s using <code>ThreadLocalRandom</code>.
If it is, the <code>maxY</code> is set to the <code>function(random)</code> as it returns the <code>y</code> value and the <code>maxX</code> is set to the <code>random</code> as that's the one that produced the largest <code>y</code> value through the <code>function()</code> method.
After the <code>for</code> loop terminates, we're left with <code>maxX</code> and <code>maxY</code> with certain values, which are essentially an approximation of what the actual maximum x and y are.
Running this piece of code will yield:
<pre><code class="hljs">The maximum of the function f(x) is (0.7461978805972576, 0.2308765022939988)
</code></pre>
And comparing this to the actual results, it's pretty accurate, with a measly 10 random points. If we increase the number of random points from 10 to 100, we get the following result:
<pre><code class="hljs">The maximum of the function f(x) is (0.735592753214972, 0.2309513390409203)
</code></pre>
There's not a lot of improvement between the two, which just goes to show that 100 iterations is completely unneeded. If we take the liberty of reducing it from 10 to 5, we'll see that's it's off:
<pre><code class="hljs">The maximum of the function f(x) is (0.6756978982704229, 0.22201906058201992)
</code></pre>
Again, depending on your accuracy needs, this might just be an acceptable solution.
Changing the algorithm to search for a minimum instead of the maximum is as easy as changing the <code>&gt;</code> operator to a <code>&lt;</code> operator in the <code>if</code> clause.
<h2 id="conclusion">Conclusion</h2>
Sometimes, an approximation of the solution is good enough for your needs and you don't need to force your machine to find the best possible solution.
This approach is extremely useful when you're dealing with problems of huge computational complexity and can improve the performance of your program by orders of magnitude.
Of course, if you don't balance the algorithm right, you'll end up with an inefficient solution, so play around with the number of random points in order to get an efficient one.!

David Landup

Stochastic Optimization refers to a category of optimization algorithms that generate and utilize random points of data for approximating a solution. In this article, we'll be exploring the simplest one - Random Search, in Java.

Stochastic Optimization: Random Search in Java

Aleksandar Bursac

Amongst many tools, Postman stands out as one of the more beginner-friendly tools. It makes automated testing easy and quick for those who are just starting out and offers a hassle-free experience, encouraging you to properly test your applications.

Getting Started with Postman

Robley Gori

Well-tested and documented code is maintainable and cleaner for the development team. In this article, we'll focus on the Unittest framework and write unit tests for Python code.

Unit Testing in Python with Unittest

Like many other popular languages, JavaScript conveniently comes with a built-in method for sorting arrays. While the end result is the same, the various JavaScript engines implement this method using different sort algorithms:
<ul>
<li>V8: Quicksort or Insertion Sort (for smaller arrays)</li>
<li>Firefox: Merge sort</li>
<li>Safari: Quicksort, Merge Sort, or Selection Sort (depending on the type of array)</li>
</ul>
The implementation doesn't really matter for the calling code, but it's interesting to see these sorting algorithms used in practice after learning about them for so long in CS intro classes.
This sort function is available as a prototype method on the <code>Array</code> class:
<pre><code class="hljs">Array.sort([compareFunc])
</code></pre>
In true JavaScript fashion, a callback is passed to this function which is used to tell the sorting algorithm how two elements compare to each other. The <code>compareFunc</code> should have two parameters, <code>a</code> and <code>b</code>, and works like this:
<ul>
<li>If <code>compareFunc</code> returns 0 then the elements are treated as equal</li>
<li>If <code>compareFunc</code> returns 1 then <code>b</code> is sorted before <code>a</code></li>
<li>If <code>compareFunc</code> returns -1 then <code>a</code> is sorted before <code>b</code></li>
</ul>
The function doesn't necessarily need to return 1 or -1, just as long as the numbers returned are 0, above 0, or below 0. So a comparator function like <code>(a, b) =&gt; a - b;</code> is perfectly valid.
If the <code>compareFunc</code> is not given then the elements are converted to strings and then sorted alphabetically. This makes sorting strings trivial. However, while sorting numbers seems like it should be straight forward, it can actually be a bit confusing here:
<pre><code class="hljs">&gt; let nums = [3, 2, 6, 50, 10];
&gt; nums.sort()
[ 10, 2, 3, 50, 6 ]
</code></pre>
As you can see, the numbers aren't in the order you would have expected. This is because, as mentioned earlier, that the default sorting method is to convert the elements to strings before doing the comparison. And as a string, &quot;50&quot; comes before &quot;6&quot;, which is why 50 isn't last in the array. To sort this array correctly, try the following instead:
<pre><code class="hljs">&gt; let nums = [3, 2, 6, 50, 10];
&gt; nums.sort((a, b) =&gt; a - b);
[ 2, 3, 6, 10, 50 ]
</code></pre>
Note: It's important to keep in mind that this method sorts in-place, which means that the original array is actually sorted and no copy is made. So, while the <code>.sort()</code> method does return the sorted array, you don't actually need to assign it to anything since the array that it is called on is sorted.
If you want to reverse the order of the sorting, just switch around the comparison of <code>a</code> and <code>b</code>. So if we want the numbers to be in descending order, you'd do the following:
<pre><code class="hljs">&gt; let nums = [3, 2, 6, 50, 10];
&gt; nums.sort((a, b) =&gt; b - a);
[ 50, 10, 6, 3, 2 ]
</code></pre>
<h2 id="sortingarrayofobjects">Sorting Array of Objects</h2>
Using a comparator function like this makes it extremely easy to sort custom objects in JavaScript. For example, let's say we have the following list of user data:
<pre><code class="hljs">let users = [
 {name: &#x27;Scotty&#x27;, age: &#x27;18&#x27;},
 {name: &#x27;Tommy&#x27;, age: &#x27;21&#x27;},
 {name: &#x27;Sally&#x27;, age: &#x27;71&#x27;},
 {name: &#x27;Billy&#x27;, age: &#x27;18&#x27;},
 {name: &#x27;Timmy&#x27;, age: &#x27;21&#x27;}
];
</code></pre>
This isn't something that the sorting algorithm can just interpret and sort itself. The order also highly depends on the application. What if we want to sort by age and then name? To do so, we could provide a comparator that combines the two:
<pre><code class="hljs">users.sort((a, b) =&gt; {
 let keyA = a.age + a.name;
 let keyB = b.age + b.name;
 if (keyA &lt; keyB) return -1;
 if (keyA &gt; keyB) return 1;
 return 0;
});
</code></pre>
This will result in the following sorted array:
<pre><code class="hljs">[ { name: 'Billy', age: '18' },
 { name: 'Scotty', age: '18' },
 { name: 'Timmy', age: '21' },
 { name: 'Tommy', age: '21' },
 { name: 'Sally', age: '71' } ]
</code></pre>
Notice that all of the users are now sorted by age. And as intended, those users with the same age are then sorted by name, like Billy and Scotty.
<h2 id="conclusion">Conclusion</h2>
In this short article we saw how to use the built-in <code>.sort()</code> method to easily sort arrays in JavaScript. This applies to any type of data, including strings, numbers, or even objects. The sort order is determined by the <code>compareFun</code> callback method, which is what allows you to determine the sort order or what object properties determine the sort order.

Scott Robinson

Like many other languages, JavaScript offers convenience methods for sorting arrays. While the result is the same, the JavaScript engines implement different algorithms, which we'll cover in this article.

Sorting Arrays in JavaScript

<h2 id="introduction">Introduction</h2>
Sorting is a crucial aspect of digesting data. For us humans, it's much more natural to sort things that have something in common like the date of publishing, alphabetical order, articles belonging to an author, from smallest to largest, etc. This makes it a lot easier to comprehend the data as it's logically connected rather than dispersed all around.
And just as important, sorted arrays are easier for computers to work with. For example, a sorted array can be searched much faster, like with the <a rel="nofollow noopener" target="_blank" href="https://en.wikipedia.org/wiki/Binary_search_algorithm">binary search</a> algorithm, which runs in O(logn) time. An algorithm like this just doesn't work without a sorted array.
<h2 id="insertionsort">Insertion Sort</h2>
Insertion Sort is one of the simpler sorting algorithms, which works considerably faster on smaller collections than the introductory <a target="_blank" href="/bubble-sort-in-java">Bubble Sort</a> and even Selection Sort even though they're all simple quadratic (O(n2) algorithms.
It's great for nearly sorted and small collections (~10 elements) which makes it extremely useful when used in combination with other, more advanced sorting algorithms such as Quicksort or <a target="_blank" href="/merge-sort-in-java">Merge Sort</a>. Java's official <code>sort()</code> implementation from the Collections API used a Dual Pivot Quicksort, though resorted to Insertion Sort for collections of size <code>7</code>.
It is generally implemented imperatively (though it can also be recursive), and represents an in-place, stable algorithm that works wonders on small datasets.
This means that it preserves the relative order of duplicate elements after sorting (in-place) and doesn't require any additional memory for sorting with a constant O(1) space complexity (stable).
Insertion Sort works a lot like humans sort cards in their hands by dividing the collection into two parts - sorted and unsorted.
It then traverses the unsorted partition and inserts each element in their relative correct place in the sorted array.
Here's a visual representation of how it works:
<img src="https://stackabuse.s3.amazonaws.com/media/insertion-sort-in-java.gif" alt="insertion sort gif">
If this doesn't make much sense now, it's explained step-by-step in the implementation below alongside the code.
<h2 id="implementation">Implementation</h2>
That being said, let's go ahead and implement the algorithm on primitive integer arrays and a collection of objects with a custom <code>compareTo()</code> method to define comparison criteria.
We could also implement the <code>Comparable</code> interface and overridde the <code>compareTo()</code> method for defining the comparison criteria, and using the Collections API, simply calling the <code>sort()</code> method provided there. However, that way, we don't implement our own sorting logic.
<h3 id="sortingarrays">Sorting Arrays</h3>
Sorting primitive integer arrays is quick and straightforward using Insertion Sort:
<pre><code class="hljs">public static void insertionSort(int array[]) {
 for (int j = 1; j &lt; array.length; j++) {
 int current = array[j];
 int i = j-1;
 while ((i &gt; -1) &amp;&amp; (array[i] &gt; current)) {
 array[i+1] = array[i];
 i--;
 }
 array[i+1] = current;
 }
}
</code></pre>
The iteration starts on the second element (the first one is by default considered sorted), and compares the first element of the unsorted array with the last element of the sorted array.
The unsorted element is &quot;safe-kept&quot; in the variable <code>current</code> and if the highest element in the sorted array is bigger than the <code>current</code> variable - the adequate portion of the sorted array is shifted to the right.
Please note that they're not swapped, it's shifted to the right and now both <code>array[j]</code> (accessed through <code>array[i+1]</code>) and <code>array[i]</code> hold the same value.
Then, regardless of whether a portion of the sorted array is shifted to the right, we set the <code>array[j]</code> to <code>current</code>, effectively inserting the safe-kept integer into its right place.
If the <code>current</code> element isn't smaller than the biggest sorted element (i.e. it's bigger), it's simply inserted at the end where it belongs.
Let's go ahead and populate a small array of integers and then sort it:
<pre><code class="hljs">int[] array = new int[]{1, 7, 5, 6, 9, 4, 2, 3};
insertionSort(array);
System.out.println(Arrays.toString(array));
</code></pre>
Running this piece of code will yield:
<pre><code class="hljs">[1, 2, 3, 4, 5, 6, 7, 9]
</code></pre>
<h3 id="sortingarraylists">Sorting ArrayLists</h3>
Sorting an <code>ArrayList</code> is a more practical/real-world example that you'll probably encounter a lot more often than primitive integers.
Since we're sorting objects depending on certain criteria, let's first define a class for our <code>Element</code> of a collection:
<pre><code class="hljs">public class Element {
 private int id;

 public Element(int id) {
 this.id = id;
 }

 // Getters and setters

 public int compareTo(Element element) {
 int res = 0;
 if (this.id &lt; element.getId()) {
 res = -1;
 }
 if (this.id &gt; element.getId()) {
 res = 1;
 }
 return res;
 }
}
</code></pre>
It contains a <code>compareTo()</code> method which accepts another <code>Element</code> to be compared to. In this mundane implementation, their <code>id</code>s are being compared, though here is where you can get creative.
Let's rework the algorithm to sort these objects instead:
<pre><code class="hljs">public static void insertionSortArrayList(List&lt;Element&gt; list) {
 for (int j = 1; j &lt; list.size(); j++) {
 Element current = list.get(j);
 int i = j-1;
 while ((i &gt; -1) &amp;&amp; ((list.get(i).compareTo(current)) == 1)) {
 list.set(i+1, list.get(i));
 i--;
 }
 list.set(i+1, current);
 }
}
</code></pre>
Not much has changed, expect for using the methods provided by a <code>List</code> and comparing the elements with our custom <code>compareTo()</code> method. Here, we check if the result of the comparison is <code>1</code> since that means that the first element is bigger than the second as defined in our method.
Now, let's populate an <code>ArrayList</code> with some elements and shuffle it:
<pre><code class="hljs">List&lt;Element&gt; list = new ArrayList&lt;&gt;();

// Create elements w/ IDs 0-24
for (int i = 0; i &lt; 25; i++) {
 list.add(new Element(i));
}

// Move the elements to a random order
Collections.shuffle(list);
</code></pre>
And now, let's sort that list:
<pre><code class="hljs">// Print list before sorting
list.forEach(e -&gt; System.out.print(e.getId() + &quot;, &quot;));

// Sort the list
insertionSortArrayList(list);

System.out.println();

// Print sorted list
list.forEach(e -&gt; System.out.print(e.getId() + &quot;, &quot;));
</code></pre>
This piece of code will yield us:
<pre><code class="hljs">4, 2, 6, 7, 0, 5, 9, 1, 8, 3,
0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
</code></pre>
<h2 id="timecomplexity">Time Complexity</h2>
The time complexity, both average and worst of Insertion sort is O(n2) which is fairly terrible. There are much better time complexities available through other, more advanced sorting algorithms, though what makes Insertion Sort stand out is how fast it is on nearly sorted and small collections.
Let's try timing it through 5 runs of small collections and 5 runs of large collections.
<pre><code class="hljs">List&lt;Element&gt; list = new ArrayList&lt;&gt;();
for (int i = 0; i &lt; 10; i++) {
 list.add(new Element(i));
}

Collections.shuffle(list);

// Print shuffled list
list.forEach(e -&gt; System.out.print(e.getId() + &quot;, &quot;));

long startTime1 = System.nanoTime();
insertionSort.insertionSortArrayList(list);
long endTime1 = System.nanoTime();

// Print sorted collection
list.forEach(e -&gt; System.out.print(e.getId() + &quot;, &quot;));
System.out.println();

// Print runtime in nanoseconds
System.out.println(&quot;Insertion Sort runtime: &quot; + (endTime1 - startTime1));
</code></pre>
<table class="table table-striped" style="white-space:nowrap; font-size:15px;">
 <tr>
 <th>Insertion Sort (10)</th>
 <th>Time(s)</th>
 <th></th>
 </tr>
 <tr>
 <td>First Run</td>
 <td>0.000058</td>
 </tr>
 <tr>
 <td>Second Run</td>
 <td>0.000085</td>
 </tr>
 <tr>
 <td>Third Run</td>
 <td>0.000073</td>
 </tr>
 <tr>
 <td>Fourth Run</td>
 <td>0.000060</td>
 </tr>
 <tr>
 <td>Fifth Run</td>
 <td>0.000073</td>
 </tr>
</table>
<table class="table table-striped" style="white-space:nowrap; font-size:15px;">
 <tr>
 <th>Insertion Sort (10k)</th>
 <th>time(s)</th>
 <th></th>
 </tr>
 <tr>
 <td>First Run</td>
 <td>0.091</td>
 </tr>
 <tr>
 <td>Second Run</td>
 <td>0.125</td>
 </tr>
 <tr>
 <td>Third Run</td>
 <td>0.104</td>
 </tr>
 <tr>
 <td>Fourth Run</td>
 <td>0.108</td>
 </tr>
 <tr>
 <td>Fifth Run</td>
 <td>0.123</td>
 </tr>
</table>
Compared to Bubble Sort which has the same time complexity, Insertion Sort is ~5 times faster.
<h2 id="conclusion">Conclusion</h2>
Insertion Sort is one of the simpler sorting algorithms, which works considerably faster on smaller collections than the introductory Bubble Sort and even Selection Sort even though they're all simple quadratic (O(n2) algorithms.
It's great for nearly sorted and small collections (~10 elements) which makes it extremely useful when used in combination with other, more advanced sorting algorithms such as Quicksort or Merge Sort.
It is generally implemented imperatively (though it can also be recursive), and represents an in-place, stable algorithm that works wonders on small datasets.
This means that it preserves the relative order of duplicate elements (in-place) and doesn't require any additional memory for sorting with a constant O(1) space complexity (stable).!

Insertion Sort is a simple sorting algorithm that works wonders on small arrays. It's often used alongside Quicksort and Merge Sort in the final stages. In this article, we'll implement Insertion Sort in Java.