<h2 id="introduction">Introduction</h2>
A few years back, callbacks were the only way we could achieve asynchronous code execution in JavaScript. There were few problems with callbacks and the most noticeable one was <a target="_blank" href="/avoiding-callback-hell-in-node-js/">&quot;Callback hell&quot;</a>.
With ES6, Promises were introduced as a solution to those problems. And finally, the <code>async/await</code> keywords were introduced for an even more pleasant experience and improved readability.
Even with the addition of new approaches, there are still a lot of native modules and libraries that use callbacks. In this article, we are going to talk about how to convert JavaScript callbacks to Promises. Knowledge of ES6 will come in handy since we'll be using features such as <a target="_blank" href="/spread-operator-in-javascript/">spread operators</a> to make things easier.
<h2 id="whatisacallback">What is a Callback</h2>
A callback is a function argument that happens to be a function itself. While we can create any function to accept another function, callbacks are primarily used in asynchronous operations.
JavaScript is an interpreted language that can only process one line of code at a time. Some tasks can take a long while to complete, like downloading or reading a large file. JavaScript offloads these long-running tasks to a different process in the browser or Node.js environment. That way, it doesn't block all the other code from being executed.
Usually, asynchronous functions accept a callback function, so that when they're complete we can process their data.
Let's take an example, we'll write a callback function which will be executed when the program successfully reads a file from our hard disk.
To this end, we'll use a text file called <code>sample.txt</code>, containing the following:
<pre><code class="hljs">Hello world from sample.txt
</code></pre>
Then let's write a simple Node.js script to <a target="_blank" href="/read-files-with-node-js/">read the file</a>:
<pre><code class="hljs">const fs = require(&#x27;fs&#x27;);

fs.readFile(&#x27;./sample.txt&#x27;, &#x27;utf-8&#x27;, (err, data) =&gt; {
 if (err) {
 // Handle error
 console.error(err);
 return;
 }

 // Data is string do something with it
 console.log(data);
});

for (let i = 0; i &lt; 10; i++) {
 console.log(i);
}
</code></pre>
Running this code should yield:
<pre><code class="hljs">0
...
8
9
Hello world from sample.txt
</code></pre>
If you run this code, you should see <code>0..9</code> being printed before the callback executed. This is because of the asynchronous management of JavaScript that we have talked about earlier. The callback, which logs the file's contents, will only be called after the file is read.
As a side note, callbacks can be used in synchronous methods as well. For example, <code>Array.sort()</code> accepts a callback function which allows you to customize how the elements are sorted.
<blockquote>
Functions that accept callbacks are called higher-order functions.
</blockquote>
Now we have a better idea of callbacks. Let's move on and see what a Promise is.
<h2 id="whatisapromise">What is a Promise</h2>
Promises were introduced with ECMAScript 2015 (commonly known as ES6) to improve the developer experience with asynchronous programming. As its name suggests, it's a promise that a JavaScript object will eventually return a value or an error.
A promise has 3 states:
<ul>
<li>Pending: The initial state indicating that the asynchronous operation is not complete.</li>
<li>Fulfilled: Meaning that the asynchronous operation completed successfully.</li>
<li>Rejected: Meaning that the asynchronous operation failed.</li>
</ul>
Most promises end up looking like this:
<pre><code class="hljs">someAsynchronousFunction()
 .then(data =&gt; {
 // After promise is fulfilled
 console.log(data);
 })
 .catch(err =&gt; {
 // If promise is rejected
 console.error(err);
 });
</code></pre>
Promises are important in modern JavaScript as they're used with the <code>async/await</code> keywords that were introduced in ECMAScript 2016. With <code>async/await</code>, we don't need to use callbacks or <code>then()</code> and <code>catch()</code> to write asynchronous code.
If the previous example were to be adapted, it would look like this:
<pre><code class="hljs">try {
 const data = await someAsynchronousFunction();
} catch(err) {
 // If promise is rejected
 console.error(err);
}
</code></pre>
This looks a lot like &quot;regular&quot; synchronous JavaScript! You can learn more about <code>async/await</code> in our article, <a href="/node-js-async-await-in-es7">Node.js Async Await in ES7</a>.
Most popular JavaScript libraries and new projects use Promises with the <code>async/await</code> keywords.
However, if you're updating an existing repo or encounter a legacy codebase, you would probably be interested in moving callback-based APIs to a Promise based APIs to improve your development experience. Your team will also be thankful.
Let's look at a couple of methods to convert callbacks to promises!
<h2 id="convertingacallbacktoapromise">Converting a Callback to a Promise</h2>
<h3 id="nodejspromisify">Node.js Promisify</h3>
Most of the asynchronous functions that accept a callback in Node.js, such as the <code>fs</code> (file system) module, have a standard style of implementation - the callback is passed as the last parameter.
For example here is how you can read a file using <code>fs.readFile()</code> without specifying the text encoding:
<pre><code class="hljs">fs.readFile(&#x27;./sample.txt&#x27;, (err, data) =&gt; {
 if (err) {
 console.error(err);
 return;
 }

 // Data is a buffer
 console.log(data);
});
</code></pre>
Note: If you specify <code>utf-8</code> as the encoding you will get a string output. If you don't specify the encoding you will get a <code>Buffer</code> output.
Moreover, the callback, which is passed to the function, should accept an <code>Error</code> as it's the first parameter. After that, there can be any number of outputs.
If the function that you need to covert to a Promise follows those rules then you can use <a target="_blank" rel="nofollow noopener" href="https://nodejs.org/dist/latest-v8.x/docs/api/util.html#util_util_promisify_original">util.promisify</a>, a native Node.js module that coverts callbacks to Promises.
In order to do that, first import the <code>util</code> module:
<pre><code class="hljs">const util = require(&#x27;util&#x27;);
</code></pre>
Then you use the <code>promisify</code> method to covert it to a promise:
<pre><code class="hljs">const fs = require(&#x27;fs&#x27;);
const readFile = util.promisify(fs.readFile);
</code></pre>
Now use the newly created function as a regular promise:
<pre><code class="hljs">readFile(&#x27;./sample.txt&#x27;, &#x27;utf-8&#x27;)
 .then(data =&gt; {
 console.log(data);
 })
 .catch(err =&gt; {
 console.log(err);
 });
</code></pre>
Alternatively, you can use the <code>async/await</code> keywords as given in the following example:
<pre><code class="hljs">const fs = require(&#x27;fs&#x27;);
const util = require(&#x27;util&#x27;);

const readFile = util.promisify(fs.readFile);

(async () =&gt; {
 try {
 const content = await readFile(&#x27;./sample.txt&#x27;, &#x27;utf-8&#x27;);
 console.log(content);
 } catch (err) {
 console.error(err);
 }
})();
</code></pre>
You can only use the <code>await</code> keyword inside a function that was created with <code>async</code>, hence why we have a function wrapper in this example. This function wrapper is also known as a <a target="_blank" href="/javascripts-immediately-invoked-function-expressions/">Immediately Invoked Function Expressions</a>.
If your callback does not follow that particular standard, don't worry. The <code>util.promisify()</code> function can allow you to <a target="_blank" rel="nofollow noopener" href="https://nodejs.org/dist/latest-v8.x/docs/api/util.html#util_custom_promisified_functions">customize</a> how the conversion happens.
Note: Promises became popular soon after they were introduced. Node.js has already converted most, if not all, of its core functions from a callback to a Promise based API.
If you need to work with files using Promises, use the <a target="_blank" rel="nofollow noopener" href="https://nodejs.org/docs/latest-v10.x/api/fs.html#fs_fs_promises_api">library that comes with Node.js</a>.
So far you've learnt how to covert Node.js standard style callbacks to promises. This module is only available on Node.js from version 8 onwards. If you're working in the browser or an earlier version of Node, it would likely be best for you to create your own promise-based version of the function.
<h3 id="creatingyourpromise">Creating Your Promise</h3>
Let's talk about how to covert callbacks to promises if the <code>util.promisify()</code> function is not available.
The idea is to create a new <code>Promise</code> object that wraps around the callback function. If the callback function returns an error, we reject the Promise with the error. If the callback function returns non-error output, we resolve the Promise with the output.
Let's start by converting a callback to a promise for a function that accepts a fixed number of parameters:
<pre><code class="hljs">const fs = require(&#x27;fs&#x27;);

const readFile = (fileName, encoding) =&gt; {
 return new Promise((resolve, reject) =&gt; {
 fs.readFile(fileName, encoding, (err, data) =&gt; {
 if (err) {
 return reject(err);
 }

 resolve(data);
 });
 });
}

readFile(&#x27;./sample.txt&#x27;)
 .then(data =&gt; {
 console.log(data);
 })
 .catch(err =&gt; {
 console.log(err);
 });
</code></pre>
Our new function <code>readFile()</code> accepts the two arguments that we've been using to read files with <code>fs.readFile()</code>. We then create a new <code>Promise</code> object that wraps over the function, which accepts the callback, in this case, <code>fs.readFile()</code>.
Instead of returning an error, we <code>reject</code> the Promise. Instead of logging the data immediately, we <code>resolve</code> the Promise. We then use our Promise-based <code>readFile()</code> function like before.
Let's try another function that accepts a dynamic number of parameters:
<pre><code class="hljs">const getMaxCustom = (callback, ...args) =&gt; {
 let max = -Infinity;

 for (let i of args) {
 if (i &gt; max) {
 max = i;
 }
 }

 callback(max);
}

getMaxCustom((max) =&gt; { console.log(&#x27;Max is &#x27; + max) }, 10, 2, 23, 1, 111, 20);
</code></pre>
The callback parameter is also the first parameter, making it a bit unusual with functions that accept callbacks.
Converting to a promise is done in the same way. We create a new <code>Promise</code> object that wraps around our function that uses a callback. We then <code>reject</code> if we encounter an error and <code>resolve</code> when we have the result.
Our promisified version looks like this:
<pre><code class="hljs">const getMaxPromise = (...args) =&gt; {
 return new Promise((resolve) =&gt; {
 getMaxCustom((max) =&gt; {
 resolve(max);
 }, ...args);
 });
}

getMaxCustom(10, 2, 23, 1, 111, 20)
 .then(max =&gt; console.log(max));
</code></pre>
When creating our promise, it doesn't matter if the function uses callbacks in a non-standard way or with many arguments. We have full control of how it's done and the principles are the same.
<h2 id="conclusion">Conclusion</h2>
While callbacks have been the default way of leveraging asynchronous code in JavaScript, Promises are a more modern method which developers believe is easier to use. If we ever encounter a codebase that uses callbacks, we can now make that function a Promise.
In this article you first saw how to use <code>utils.promisfy()</code> method in Node.js to convert functions that accept callbacks into Promises. You then saw how to create your own <code>Promise</code> object that wraps around a function that accepts a callback without the use of external libraries.
With this, a lot of legacy JavaScript code can easily be intermingled with more modern codebases and practices! As always the source code is available on <a rel="nofollow noopener" target="_blank" href="https://github.com/jkasun/sa-covert-callbacks-to-promises">GitHub</a>.

Marcus Sanatan

Janith Kasun

Asynchronous JavaScript heavily used callbacks, but now use Promises as it's easier to manage. In this article, we'll convert callbacks to Promises.

Converting Callbacks to Promises in Node.js

François Dupire

Hibernate is a popular vendor for JPA. In this article, we'll do a deep dive into the basic mappings in Hibernate and map a Java domain model into a database.

Guide to JPA with Hibernate - Basic Mapping

Functions in Python are used to implement logic that you want to execute repeatedly at different places in your code. You can pass data to these functions via function arguments. In addition to passing arguments to functions via a function call, you can also set default argument values in Python functions. These default values are assigned to function arguments if you do not explicitly pass a parameter value to the given argument. Parameters are the values actually passed to function arguments.
In this article, you will see how to use default arguments in Python functions. But first, we will see how to define a function in Python and how to explicitly pass values to function arguments.
<h2 id="functionwithoutarguments">Function without Arguments</h2>
Let's define a very simple Python function without any arguments:
<pre><code class="hljs">def my_function():
 print(&quot;This is a function without arguments&quot;)
</code></pre>
The above script defines a function, <code>my_function</code>, which doesn't accept any arguments and simply prints a string.
The following script shows how you'd actually call the <code>my_function()</code> function:
<pre><code class="hljs">my_function()
</code></pre>
In the output, you should see a simple statement printed to the screen by the <code>my_function()</code> function:
<pre><code class="hljs">This is a function without arguments
</code></pre>
<h2 id="functionwithexplicitarguments">Function with Explicit Arguments</h2>
Let's now define a simple Python function where we have to pass multiple values for the function arguments. If you do not specify values for all the function arguments, you will see an error.
Here is the function we'll be using as an example:
<pre><code class="hljs">def func_args(integer1, integer2):
 result = integer1 + integer2
 return result
</code></pre>
In the code above we create a function, <code>func_args()</code>, with two arguments <code>integer1</code> and <code>integer2</code>. The function adds the values passed in the two arguments and returns the result to the function caller.
Let's try calling the above function with two arguments:
<pre><code class="hljs">result = func_args(10, 20)
print(result)
</code></pre>
The above script calls the <code>func_args()</code> method with two parameter values, i.e. 10 and 20. In the output, you should see the sum of these two values, i.e. 30.
Let's now try to call the <code>func_args()</code> method without passing values for the arguments:
<pre><code class="hljs">result = func_args()
print(result)
</code></pre>
In the output, you should see the following error:
<pre><code class="hljs">---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
&lt;ipython-input-13-3449c8e5e188&gt; in &lt;module&gt;
----&gt; 1 result = func_args()
 2 print(result)

TypeError: func_args() missing 2 required positional arguments: &#x27;integer1&#x27; and &#x27;integer2&#x27;
</code></pre>
The error is quite clear, the function call to <code>func_args()</code> is missing the 2 required positional arguments, <code>integer1</code> and <code>integer2</code>. The error basically tells us that we need to pass values for the <code>integer1</code> and <code>integer2</code> arguments via the function call.
Let's now pass a value for one of the arguments and see what happens:
<pre><code class="hljs">result = func_args(10)
print(result)
</code></pre>
Now in the output, you should again see the following error:
<pre><code class="hljs">---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
&lt;ipython-input-14-640ec7b786e1&gt; in &lt;module&gt;
----&gt; 1 result = func_args(10)
 2 print(result)

TypeError: func_args() missing 1 required positional argument: &#x27;integer2&#x27;
</code></pre>
The difference here is that the error now tells us that the value for one of the positional arguments, i.e. <code>integer2</code>, is missing. This means that without any default argument values set, you have to pass values explicitly for all the function arguments, otherwise an error will be thrown.
What if you want your function to execute with or without the argument values in the function call? This is where default arguments in Python functions come in to play.
<h2 id="functionwithdefaultarguments">Function with Default Arguments</h2>
Default arguments in Python functions are those arguments that take default values if no explicit values are passed to these arguments from the function call. Let's define a function with one default argument.
<pre><code class="hljs">def find_square(integer1=2):
 result = integer1 * integer1
 return result
</code></pre>
The above script defines a function <code>find_square()</code> with one default argument i.e. <code>integer1</code>. The default value for the <code>integer1</code> argument is set to 2. If you call the <code>find_square()</code> method with a value for the <code>integer1</code> argument, the <code>find_square()</code> function will return the square of that value.
Otherwise, if you do not pass any value for the <code>integer1</code> argument of the <code>find_square()</code> function, you will see that the default value, i.e. 2, will be assigned to <code>integer1</code>, and the function will return the square of 2, i.e. 4.
Let's first call the <code>find_square()</code> method with the argument value of 10:
<pre><code class="hljs">result = find_square(10)
print(result)
</code></pre>
Output:
<pre><code class="hljs">100
</code></pre>
When you execute the above script, the value 10 overwrites the default value of 2 for the argument <code>integer1</code> of the <code>find_square()</code> function and the function returns 100, which is square of 10.
Now we will call the <code>find_square()</code> function without any value for the <code>argument1</code> argument. In this case, you will see that 4 will be returned by <code>find_square()</code> function since in the absence of the value for the <code>find_square()</code> function, the default value of 2 will be used as the value for the <code>find_square()</code> function, as shown below:
<pre><code class="hljs">result = find_square()
print(result)
</code></pre>
Output:
<pre><code class="hljs">4
</code></pre>
A Python function can have multiple default arguments as well. For instance, in the following script, the function adds the integers number passed to the arguments. If none of the integer values is passed to the function, the default arguments would take values 2 and 4 respectively, as shown below:
<pre><code class="hljs">def add_ints(integer1=2, integer2=4):
 result = integer1 + integer2
 return result
</code></pre>
Let's first call the <code>add_ints()</code> function without any parameters:
<pre><code class="hljs">result = add_ints()
print(result)
</code></pre>
Output:
<pre><code class="hljs">6
</code></pre>
Since we did not pass any values for the function arguments, the default argument values, i.e 2 and 4, have been added together.
Let's now pass two of our own values to the <code>add_ints()</code> function:
<pre><code class="hljs">result = add_ints(4, 8)
print(result)
</code></pre>
Output:
<pre><code class="hljs">12
</code></pre>
As expected, 4 and 8 were added together to return 12.
A Python function can have both normal (explicit) and default arguments at the same time. Let's create a function <code>take_power()</code>. The first argument to the function is a normal argument while the second argument is a default argument with a value of 2. The function returns the result of the value in the first argument raised to the power of value in the second argument.
<pre><code class="hljs">def take_power(integer1, integer2=2):
 result = 1
 for i in range(integer2):
 result = result * integer1

 return result
</code></pre>
Let's first pass only a single argument:
<pre><code class="hljs">result = take_power(3)
print(result)
</code></pre>
Output:
<pre><code class="hljs">9
</code></pre>
In the script above, 3 has been passed as a value to the <code>integer1</code> argument of the <code>take_power()</code> function. No value has been provided for the default argument <code>integer2</code>. Hence, the default value of 2 will be used to take the power of 3 and you will see 9 in the output.
Let's now pass two values to the <code>take_power()</code> function.
<pre><code class="hljs">result = take_power(3, 4)
print(result)
</code></pre>
In the output, you will see 3 raised to the fourth power, i.e. 81.
It's important to note that parameters with default arguments cannot be followed by parameters with no default argument. Take the following function for example:
<pre><code class="hljs">def take_power(integer1=2, integer2):
 result = 1
 for i in range(integer2):
 result = result * integer1

 return result
</code></pre>
Trying to call this function will result in an error since the first argument has a default, but the second one does not:
<pre><code class="hljs">result = take_power(3, 4)
print(result)
</code></pre>
Executing this code results in the following error:
<pre><code class="hljs">---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
&lt;ipython-input-14-640ec7b786e1&gt; in &lt;module&gt;
----&gt; 1 def take_power(integer1=3, integer2):
 2 result = 1

SyntaxError: non-default argument follows default argument
</code></pre>

Usman Malik

The article explains the difference between normal arguments and the default arguments in Python functions with the help of different examples. 

Default Arguments in Python Functions

<h2 id="introduction">Introduction</h2>
In this article, we'll be implementing the Observer Design Pattern to solve a commonly occurring problem in object-oriented software development.
Design Patterns are standardized solutions to common problems in the software development industry. Being familiar with them, a developer is able to recognize where each should be implemented and how it would help solve a particular design issue.
Early design disaster prevention can save a huge amount of time and cost for a team trying to push out a product.
<h2 id="behavioraldesignpatterns">Behavioral Design Patterns</h2>
<a target="_blank" href="/behavioral-design-patterns-in-java">Behavioral Design Patterns</a> provide responsibility assignment between instances of classes. Also, they define types of relationships and communication between objects.
The main idea is to achieve some expected behavior of an application and create a flexible design at the same time.
<h2 id="observerdesignpattern">Observer Design Pattern</h2>
The Observer Design Pattern is a way to design a subsystem that allows many objects to respond automatically to changes of a particular object that's being &quot;observed&quot;.
It addresses the decomposition of an <code>Observable</code> and <code>Observer</code>s - or a publisher and subscribers.
For an <code>Observable</code> object, we use the term Subject. Objects that are subscribed to the Subject's changes are called Observers. A Subject and Observers are typically in one-to-many dependency.
The Observer Design Pattern is also known as the Event-Subscriber or the Listener pattern.
Note: Java has an official implementation of the Observer Design Pattern and it's the backbone of JMS (Java Message Service). It's generally used for building even-driven applications, though, the official implementation isn't really wide-spread and many people implement the pattern according to their own use-cases.
<h2 id="motivation">Motivation</h2>
Probably the most well-known example is a button listener that perform an action upon clicking the button. This pattern, in general, is pretty common in Java GUI components. It is a way to react to events happening with visual objects.
As a social media user, you might be following some people. We can say that you are an observer of your friend's social media feed (Subject of observation) and you get notifications about their new posts and life events. Interestingly, your friend is an Observer of your feed as well.
Let's add more complexity and say that you probably have several or even hundreds of different observers and they can react differently to your posts. It is possible that one object can be a subject of observation and an observer of another subject. They can even have this relationship between themselves.
As a more real-world example - a fire alarm in a mall has to notify all stores that a fire is going on. These stores are observing the fire alarm signal and reacting to its changes.
As you can see, the problem is pretty widespread and oftentimes it isn't trivial to solve with other designs.
<h2 id="implementation">Implementation</h2>
Let's assume that a store chain wants to notify their loyal customers of an ongoing sale. The system would send a short message to all subscribed customers whenever a sale has been activated.
In this case, our store is the subject of observation, and our customers are observing it. Let's define the <code>Subject</code> and <code>Observer</code> interfaces for our objects to implement:
<pre><code class="hljs">public interface Subject {
 public void addSubscriber(Observer observer);
 public void removeSubscriber(Observer observer);
 public void notifySubscribers();
}
</code></pre>
The <code>Subject</code> interface is pretty straightforward. It provides methods to add and remove subscribers/observers and notify them of a change.
The <code>Observer</code> interface is even simpler:
<pre><code class="hljs">public interface Observer {
 public void update(String message);
}
</code></pre>
The only thing an <code>Observer</code> really needs is to know when there's an update from their subject. Their behavior based on this update will differ between classes.
With our interfaces out the way, let's implement the <code>Subject</code> interface through a store:
<pre><code class="hljs">public class Store implements Subject {
 private List&lt;Observer&gt; customers = new ArrayList&lt;&gt;();

 @Override
 public void addSubscriber(Observer customer) {
 customers.add(customer);
 }
 @Override
 public void removeSubscriber(Observer customer) {
 customers.remove(customer);
 }
 @Override
 public void notifySubscribers() {
 System.out.println(&quot;A new item is on sale! Act fast before it sells out!&quot;);
 for(Observer customer: customers) {
 customer.update(&quot;Sale!&quot;);
 }
 }
}
</code></pre>
The store contains a list of observers (customers) and implements the methods for the addition and removal of customers from the list.
The <code>notifySubscribers()</code> method simply loops through the list of them and sends them an update.
We can have as many <code>Observer</code> implementations as we'd like. It's only natural for people to react differently to a sale. A shopaholic will likely jump in rejoice while a passive customer will likely make note of the sale and remember it for later.
Let's go ahead and implement these two types of customers:
<pre><code class="hljs">public class ShopaholicCustomer implements Observer {
 @Override
 public void update(String message) {
 processMessage(message);
 }
 private void processMessage(String message) {
 System.out.println(&quot;Shopaholic customer is interested in buying the product on sale!&quot;);
 // A complex psychologic response to a sale by a shopaholic
 }
}

public class PassiveCustomer implements Observer {
 @Override
 public void update(String message) {
 System.out.println(&quot;Passive customer made note of the sale.&quot;);
 // Passive customer does not react to the message too much
 }
}
</code></pre>
And finally, let's take a look at the Observer Design Pattern in action by activating a sale in a shop that's being watched by a few of customers:
<pre><code class="hljs">public static void main(String[] args) {
 // Initialization
 Subject fashionChainStores = new ChainStores();
 Observer customer1 = new PassiveCustomer();
 Observer customer2 = new ShopaholicCustomer();
 Observer customer3 = new ShopaholicCustomer();

 // Adding two customers to the newsletter
 fashionChainStores.addSubscriber(customer1);
 fashionChainStores.addSubscriber(customer2);

 // Notifying customers (observers)
 fashionChainStores.notifySubscribers();

 // A customer has decided not to continue following the newsletter
 fashionChainStores.removeSubscriber(customer1);

 // customer2 told customer3 that a sale is going on
 fashionChainStores.addSubscriber(customer3);

 // Notifying the updated list of customers
 fashionChainStores.notifySubscribers();
}
</code></pre>
And running this piece of code will yield:
<pre><code class="hljs">A new item is on sale! Act fast before it sells out!
Passive customer made note of the sale.
Shopaholic customer is interested in buying the product on sale!
A new item is on sale! Act fast before it sells out!
Shopaholic customer is interested in buying the product on sale!
Shopaholic customer is interested in buying the product on sale!
</code></pre>
Changing the state of the store results in the changed state of the subscribed customers. This same principle would apply to a fire alarm or a news feed. As soon as someone posts a post, all of the observers are notified and take some action depending on their responsibility/interest.
We can modify the list of a subject's observers at any point. Also, we can add any implementation of the <code>Observer</code> interface. This gives us the ability to build a robust event-driven system that pushes updates to observers and updates the whole system based on the changes in a single particular object.
<h2 id="prosandcons">Pros and Cons</h2>
The Observer Design Pattern is a great contribution to the support of the <a target="_blank" href="/object-oriented-design-principles-in-java/#theopenclosedprinciple">Open/Close Design Principle</a>. It helps us build designs with high cohesion but loose coupling.
In other words, the Observer and the Subject have a strictly specified mission. The Subject updates an Observer with some information and doesn't know about the Observer's implementation. This characteristic gives us flexibility.
This pattern allows us to add and remove Observers at any time. You don't need to modify either Subject nor Observer for it.
There is an issue in the Observer Design Pattern though.
<blockquote>
The order of notifications is not under our control. There is no priority among subscribers during notification.
</blockquote>
This means that if an Observer's execution is dependent on another Observer's execution beforehand, there's no guarantee that these two will execute in that order.
However, it is valuable to understand that a pattern is a high-level description of a particular solution. When we apply a pattern to two different applications, our code will be different. We can sort our Observers and they will get a notification in an expected order. This is not a feature of the Observer Design Pattern, but it is something we can do.
<h2 id="conclusion">Conclusion</h2>
When you know design patterns, some complex problems can be boiled down to proven simple solutions.
The Observer Design Pattern is really useful in event-driven systems where many objects may depend on a state of another object. If implemented poorly, this will result in a coupled and stiff application where it's really hard to test objects individually and updating code will be a hassle.
In this article, we've explored how we can solve this issue and make a flexible, decoupled solution that your team will be thankful for.

Victoria Seniuk

The Observer Design Pattern is a widespread solution to event-driven systems. In this article, we'll implement our own event-driven, decoupled system in Java.

The Observer Design Pattern in Java

<h2 id="introduction">Introduction</h2>
<a rel="nofollow noopener" target="_blank" href="https://aws.amazon.com/">Amazon Web Services</a> (AWS) is a cloud computing provider with a number of extremely popular services. Ever since their launch back in 2006, they've become a key player in the development and deployment of major enterprise applications. Their services are scalable, flexible, and groundbreaking in many aspects, while keeping the cost relatively low compared to self-hosting.
These are just some of the reasons why major companies like Adobe, Airbnb, Autodesk, BMW, the European Space Agency, Ticketmaster, Xiaomi, Twitch, Netflix, Facebook, LinkedIn, Twitter, etc. started hosting their applications on the AWS platform..
We've compiled a series of articles on integrating with these services using Node.js in order to help you get up to speed with some of AWS's most popular services.
<h2 id="filestorage">File Storage</h2>
<h3 id="awssimplestorageservices3">AWS Simple Storage Service (S3)</h3>
Much of the software and web apps we build today requires some kind of hosting for files - images, invoices, audio files, etc. The traditional way to store files was just to just save them on the server's HDD.
However, saving files onto the HDD of the server comes with limitations, such as not being able to scale up, being required to allocate space before using it, and much higher pricing. Not to mention, requesting a huge amount of large files, like images for example, can really put a strain on the server.
To offload the servers, developers started hosting files with could storage providers such as <a rel="nofollow noopener" target="_blank" href="https://aws.amazon.com/s3/">AWS S3</a>, Google Cloud Storage, etc.
In this article we will show you how to write Node.js code to upload files to S3:
<ul>
<li><a target="_blank" href="/uploading-files-to-aws-s3-with-node-js/">Uploading Files to AWS S3 with Node.js</a></li>
</ul>
<h2 id="messagingsupport">Messaging Support</h2>
<h3 id="awssimplenotificationservicesns">AWS Simple Notification Service (SNS)</h3>
<a rel="nofollow noopener" target="_blank" href="https://aws.amazon.com/sns/">AWS Simple Notification Service</a> (SNS) is a super scalable service that allows users to implement the publish/subscribe model with ease.
This allows us to send texts, emails, push notifications, or other automated messages to other targets across multiple channels at the same time.
In this post, you'll learn how to build a web app that can publish a message to multiple subscribers at once via email, all using SNS:
<ul>
<li><a target="_blank" href="/publishing-and-subscribing-to-aws-sns-messages-with-node-js/">Publishing and Subscribing to AWS SNS Messages with Node.js</a></li>
</ul>
<h3 id="awssimplequeueservicesqs">AWS Simple Queue Service (SQS)</h3>
With the increased complexity of modern software systems came the need to break up systems that had outgrown their initial size. This increase in the complexity of systems made it harder to maintain, update, and upgrade them.
This paved the way for microservices that allowed massive monolithic systems to be broken down into smaller services that are loosely coupled but interact to deliver the total functionality of the initial monolithic solution. The loose coupling provides agility and eases the process of maintenance and the addition of new features without having to modify entire systems.
It is in these microservice architectures that Queueing Systems come in handy to facilitate the communication between separate services that make up the entire application.
In this post, we will dive into queueing systems, particularly <a rel="nofollow noopener" target="_blank" href="https://aws.amazon.com/sqs/">Amazon's Simple Queue Service</a> (SQS) and demonstrate how we can leverage its features in a microservice environment:
<ul>
<li><a target="_blank" href="/message-queueing-in-node-js-with-aws-sqs/">Message Queueing in Node.js with AWS SQS</a></li>
</ul>
<h2 id="databasesupport">Database Support</h2>
<h3 id="awsrelationaldatabaseservicerds">AWS Relational Database Service (RDS)</h3>
It's not an overstatement anymore to say that information and data runs the world. Almost any application, from social media and e-commerce websites, to simple time tracker and drawing apps, relies on the very basic and fundamental task of storing and retrieving data in order to run as expected.
<a rel="nofollow noopener" target="_blank" href="https://aws.amazon.com/rds/">Amazon's Relational Database Service</a> (RDS) provides an easy way to get a database set up in the cloud using any of a wide range of relational database technologies.
In this article, you'll learn how to set up a database on RDS and store data in it with a Node web application:
<ul>
<li><a target="_blank" href="/using-aws-rds-with-node-js-and-express-js/">Using AWS RDS with Node.js and Express</a></li>
</ul>
<h2 id="cloudcomputing">Cloud Computing</h2>
<h3 id="awselasticcomputecloudec2">AWS Elastic Compute Cloud (EC2)</h3>
Once you've written a web application, there are dozens of offerings to get your app online and usable by other people. One well-known offering, and the most popular service on AWS, is <a rel="nofollow noopener" target="_blank" href="https://aws.amazon.com/ec2/">Elastic Compute Cloud</a> (EC2).
EC2 is a core part of AWS, and a lot of AWS's other services are built on top of it - therefore it's good to get an understanding of what EC2 is and how to deploy your application to it.
In this tutorial, we're going to create a basic Node.js app with Docker, start and configure an EC2 instance, and deploy our app to it:
<ul>
<li><a target="_blank" href="/deploying-node-js-apps-to-aws-ec2-with-docker/">Deploying Node.js Apps to AWS EC2 with Docker</a></li>
</ul>
<h3 id="awslambda">AWS Lambda</h3>
The family of computing architecture that AWS Lambda belongs to is called Serverless Computing, or sometimes Function as a Service. It's groundbreaking for developers because there is no need to maintain servers. Every time an AWS Lambda function is created and run, a container is spun up to serve it, which is shared among other containers to keep utilization of resources high.
The code is deployed into the container and then executed. Hence making every subsequent request faster because AWS is skipping the initial creation of the container if it already exists.
In this article you'll learn more about the Lambda service and how to get your code up and running:
<ul>
<li><a target="_blank" href="/getting-started-with-aws-lambda-and-node-js/">Getting Started with AWS Lambda with Node.js</a></li>
</ul>

David Landup

Amazon Web Services have become a key player in the biggest enterprise applications. In this article, we've compiled a list of articles that teach you to use AWS with Node.js.

Getting Started with Amazon Web Services in Node.js

Luka Čupić

Simulated Annealing is an evolutionary optimization algorithm based on annealing in metallurgy. In this article, we'll implement Simulated Annealing in Java to solve the Traveling Salesman Problem.

Simulated Annealing Optimization Algorithm in Java

<h2 id="introduction">Introduction</h2>
In this tutorial, we are going to talk about a very powerful optimization (or automation) algorithm, i.e. the Grid Search Algorithm. It is most commonly used for hyperparameter tuning in machine learning models. We will learn how to implement it using Python, as well as apply it in an actual application to see how it can help us choose the best parameters for our model and improve its accuracy. So let's start.
<h2 id="prerequisites">Prerequisites</h2>
To follow this tutorial, you should have a basic understanding of Python or some other programming language. It is preferred, but not essential, that you have some basic knowledge of machine learning as well. Other than that, this article is beginner-friendly and can be followed by anyone.
<h2 id="installation">Installation</h2>
To go through the tutorial, you need to have the following libraries/frameworks installed in your system:
<ol>
<li><a rel="nofollow noopener" target="_blank" href="https://www.python.org/downloads/">Python 3</a></li>
<li><a rel="nofollow noopener" target="_blank" href="https://numpy.org">NumPy</a></li>
<li><a rel="nofollow noopener" target="_blank" href="https://pandas.pydata.org">Pandas</a></li>
<li><a rel="nofollow noopener" target="_blank" href="https://keras.io">Keras</a></li>
<li><a rel="nofollow noopener" target="_blank" href="https://scikit-learn.org/stable/">Scikit-Learn</a></li>
</ol>
They are all quite simple to install - you can click on each to go to their respective websites where detailed installation instructions are provided. Generally, the packages can be installed using pip:
<pre><code class="hljs">$ pip install numpy pandas tensorflow keras scikit-learn
</code></pre>
If you run in to any issues, please refer to the official documentation from each package.
<h2 id="whatisgridsearch">What is Grid Search?</h2>
Grid search is essentially an optimization algorithm which lets you select the best parameters for your optimization problem from a list of parameter options that you provide, hence automating the 'trial-and-error' method. Although it can be applied to many optimization problems, but it is most popularly known for its use in machine learning to obtain the parameters at which the model gives the best accuracy.
Let's assume that your model takes the below three parameters as input:
<ol>
<li>Number of hidden layers [2, 4]</li>
<li>Number of neurons in each layer [5, 10]</li>
<li>Number of epochs [10, 50]</li>
</ol>
If for each parameter input we wish to try out two options (as mentioned in square brackets above), it totals up to 23=8 different combinations (for example, one possible combination is [2,5,10]). Doing this manually would be a headache.
Now imagine if we had 10 different input parameters and we wanted to try out 5 possible values for each parameter. It would require manual input from our side each time we wish to change a parameter value, rerun the code, and keep track of the results for all the combinations of parameters. Grid Search automates that process, as it simply takes the possible values for each parameter and runs the code to try out all possible combinations, outputs the result for each combination, as well as outputs the combination which gives the best accuracy. Useful, no?
<h2 id="gridsearchimplementation">Grid Search Implementation</h2>
Alright, enough talk. Lets apply Grid Search on an actual application. Discussing the Machine Learning and Data Preprocessing part is out of scope for this tutorial, so we would simply be running its code and talk in-depth about the part where Grid Search comes in. Lets start!
We will be using the Pima Indian Diabetes dataset which contains information about whether or not a patient is diabetic based on different attributes such blood glucose glucoses concentration, blood pressure, etc. Using Pandas <code>read_csv()</code> method you can directly import the dataset from an online resource.
The following script imports the required libraries:
<pre><code class="hljs">from sklearn.model_selection import GridSearchCV, KFold
from keras.models import Sequential
from keras.layers import Dense, Dropout
from keras.wrappers.scikit_learn import KerasClassifier
from keras.optimizers import Adam
import sys
import pandas as pd
import numpy as np
</code></pre>
The following script imports the dataset and sets the column headers for the dataset.
<pre><code class="hljs">columns = [&#x27;num_pregnant&#x27;, &#x27;glucose_concentration&#x27;, &#x27;blood_pressure&#x27;, &#x27;skin_thickness&#x27;,
 &#x27;serum_insulin&#x27;, &#x27;BMI&#x27;, &#x27;pedigree_function&#x27;, &#x27;age&#x27;, &#x27;class&#x27;]

data_path = &quot;https://raw.githubusercontent.com/mkhalid1/Machine-Learning-Projects-Python-/master/Grid%20Search/pima-indians-diabetes.csv&quot;

df = pd.read_csv(data_path, names=columns)
</code></pre>
Let's take a look at the first 5 rows of the dataset:
<pre><code class="hljs">df.head()
</code></pre>
Output:
<img src="https://stackabuse.s3.amazonaws.com/media/optimization-algorithm-grid-search-in-Python-1.PNG" alt="diabetes dataset">
As you can see, these 5 rows are all labels to describe each column (there are actually 9 of them), so they have no use to us. We'll start by removing these non-data rows and then replace all the <code>NaN</code> values with 0:
<pre><code class="hljs"># Remove first 9 non-data rows
df = df.iloc[9:]

# Replace NaN (Not a Number) values with 0 in each column
for col in columns:
 df[col].replace(0, np.NaN, inplace=True)

df.dropna(inplace=True) # Drop all rows with missing values
dataset = df.values # Convert dataframe to numpy array
</code></pre>
The following script divides the data into the feature and label sets and applies the standard scaling on the dataset:
<pre><code class="hljs">X = dataset[:,0:8]
Y = dataset[:, 8].astype(int)

# Normalize the data using sklearn StandardScaler
from sklearn.preprocessing import StandardScaler

scaler = StandardScaler().fit(X)

# Transform and display the training data
X_standardized = scaler.transform(X)

data = pd.DataFrame(X_standardized)
</code></pre>
The following method creates our simple deep learning model:
<pre><code class="hljs">def create_model(learn_rate, dropout_rate):
 # Create model
 model = Sequential()
 model.add(Dense(8, input_dim=8, kernel_initializer=&#x27;normal&#x27;, activation=&#x27;relu&#x27;))
 model.add(Dropout(dropout_rate))
 model.add(Dense(4, input_dim=8, kernel_initializer=&#x27;normal&#x27;, activation=&#x27;relu&#x27;))
 model.add(Dropout(dropout_rate))
 model.add(Dense(1, activation=&#x27;sigmoid&#x27;))

 # Compile the model
 adam = Adam(lr=learn_rate)
 model.compile(loss=&#x27;binary_crossentropy&#x27;, optimizer=adam, metrics=[&#x27;accuracy&#x27;])
 return model
</code></pre>
This is all the code that you would need to run in order to load the dataset, preprocess it, and create your machine learning model. Since, we are only interested in seeing the functionality of Grid Search, I have not performed the train/test split, and we'd be fitting the model on the entire dataset.
In the next section we'll start to see how Grid Search makes our life easier by optimizing our parameters.
<h3 id="trainingthemodelwithoutgridsearch">Training the Model without Grid Search</h3>
In the code below, we will create a model using parameter values that we decided on randomly, or based on our intuition, and see how our model performs:
<pre><code class="hljs"># Declare parameter values
dropout_rate = 0.1
epochs = 1
batch_size = 20
learn_rate = 0.001

# Create the model object by calling the create_model function we created above
model = create_model(learn_rate, dropout_rate)

# Fit the model onto the training data
model.fit(X_standardized, Y, batch_size=batch_size, epochs=epochs, verbose=1)
</code></pre>
Output:
<pre><code class="hljs">Epoch 1/1
130/130 [==============================] - 0s 2ms/step - loss: 0.6934 - accuracy: 0.6000
</code></pre>
The accuracy we got, as you can see below, is <code>60.00%</code>. This is quite low, but nothing to worry about! We still have Grid Search to try and save the day. So, let's get to it.
<h3 id="optimizinghyperparametersusinggridsearch">Optimizing Hyper-parameters using Grid Search</h3>
If you do not use Grid Search, you can directly call the <code>fit()</code> method on the model we have created above. However, to use Grid Search, we need to pass in some parameters to our <code>create_model()</code> function. Furthermore, we need to declare our grid with different options that we would like to try for each parameter. Let's do that in parts.
First we modify our <code>create_model()</code> function to accept parameters from the calling function:
<pre><code class="hljs">def create_model(learn_rate, dropout_rate):
 # Create model
 model = Sequential()
 model.add(Dense(8, input_dim=8, kernel_initializer=&#x27;normal&#x27;, activation=&#x27;relu&#x27;))
 model.add(Dropout(dropout_rate))
 model.add(Dense(4, input_dim=8, kernel_initializer=&#x27;normal&#x27;, activation=&#x27;relu&#x27;))
 model.add(Dropout(dropout_rate))
 model.add(Dense(1, activation=&#x27;sigmoid&#x27;))

 # Compile the model
 adam = Adam(lr=learn_rate)
 model.compile(loss=&#x27;binary_crossentropy&#x27;, optimizer=adam, metrics=[&#x27;accuracy&#x27;])
 return model

# Create the model
model = KerasClassifier(build_fn=create_model, verbose=1)
</code></pre>
Now, we are ready to implement our Grid Search algorithm and fit the dataset on it:
<pre><code class="hljs"># Define the parameters that you wish to use in your Grid Search along
# with the list of values that you wish to try out
learn_rate = [0.001, 0.02, 0.2]
dropout_rate = [0.0, 0.2, 0.4]
batch_size = [10, 20, 30]
epochs = [1, 5, 10]

seed = 42

# Make a dictionary of the grid search parameters
param_grid = dict(learn_rate=learn_rate, dropout_rate=dropout_rate, batch_size=batch_size, epochs=epochs )

# Build and fit the GridSearchCV
grid = GridSearchCV(estimator=model, param_grid=param_grid,
 cv=KFold(random_state=seed), verbose=10)

grid_results = grid.fit(X_standardized, Y)

# Summarize the results in a readable format
print(&quot;Best: {0}, using {1}&quot;.format(grid_results.best_score_, grid_results.best_params_))

means = grid_results.cv_results_[&#x27;mean_test_score&#x27;]
stds = grid_results.cv_results_[&#x27;std_test_score&#x27;]
params = grid_results.cv_results_[&#x27;params&#x27;]

for mean, stdev, param in zip(means, stds, params):
 print(&#x27;{0} ({1}) with: {2}&#x27;.format(mean, stdev, param))
</code></pre>
Output:
<pre><code class="hljs">Best: 0.7959183612648322, using {&#x27;batch_size&#x27;: 10, &#x27;dropout_rate&#x27;: 0.2, &#x27;epochs&#x27;: 10, &#x27;learn_rate&#x27;: 0.02}
</code></pre>
In the output, we can see it gives us the parameter combination which yields the best accuracy.
It is safe to say that the Grid Search was quite easy to implement in Python and saved us a lot of time, in terms of human labor. You can just list down all the parameters you'd like to tune, declare the values to be tested, run your code, and forget about it. No more input required from your side. Once the best parameters combination has been found, you can simply use that for your final model.
<h2 id="conclusion">Conclusion</h2>
To sum it up, we learned what Grid Search is, how it can help us optimize our model and the benefits it entails like automation. Furthermore, we learned how to implement it in a few lines of code using Python Language. To see its effectiveness, we also trained a Machine Learning model with and without performing Grid Search, and the accuracy was 19% higher with Grid Search.

Muhammad Junaid Khalid

The article explains how to use the grid search optimization algorithm in Python for tuning hyper-parameters for deep learning algorithms. 

Grid Search Optimization Algorithm in Python

PostgreSQL is a really popular, free, open-source relational database. The node-postgres module is a widely-employed module that bridges Node with it. In this article, we'll be developing simple CRUD functionality for a PostgreSQL database.

Integrating PostgreSQL with Node.js and node-postgres

Using PostgreSQL with Node.js and node-postgres

In this article, you will see how to remove stop words using Python's NLTK, Gensim, and SpaCy libraries along with a custom script for stop word removal.