Guest Contributor

The article shows how to read and write CSV files using Python's Pandas library. To read a CSV file, the `read_csv()` method of the Pandas library is used.

Reading and Writing CSV Files in Python with Pandas

Janith Kasun

Using Handlebars with Node, we can create dynamic webpages that render on the server-side. Using conditionals, loops, partials and custom helper functions, with Handlebars, our web pages become more than just static HTML.

Guide to Handlebars: Templating Engine for Node/JavaScript

<h2 id="introduction">Introduction</h2>
The question pops up a lot both on the internet and when someone would like to check your knowledge of how Java treats variables:
<blockquote>
Does Java &quot;pass-by-reference&quot; or &quot;pass-by-value&quot; when passing arguments to methods?
</blockquote>
It seems like a simple question (it is), but many people get it wrong by saying:
<blockquote>
Objects are passed by reference and primitive types are passed by value.
</blockquote>
A correct statement would be:
<blockquote>
Object references are passed by value, as are primitive types. Thus, Java passes by value, not by reference, in all cases.
</blockquote>
This may sound unintuitive for some, as it's common for lectures to showcase the difference between an example like this:
<pre><code class="hljs">public static void main(String[] args) {
 int x = 0;
 incrementNumber(x);
 System.out.println(x);
}

public static void incrementNumber(int x) {
 x += 1;
}
</code></pre>
and an example like this:
<pre><code class="hljs">public static void main(String[] args) {
 Number x = new Number(0);
 incrementNumber(x);
 System.out.println(x);
}

public static void incrementNumber(Number x) {
 x.value += 1;
}

public class Number {
 int value;
 // Constructor, getters and setters
}
</code></pre>
The first example will print:
<pre><code class="hljs">0
</code></pre>
While the second example will print:
<pre><code class="hljs">1
</code></pre>
The reason for this difference is often understood to be because of &quot;pass-by-value&quot; (first example, the copied value of <code>x</code> is passed and any operation on the copy won't reflect on the original value) and &quot;pass-by-reference&quot; (second example, a reference is passed, and when altered, it reflects the original object).
In the proceeding sections, we'll explain why this is incorrect.
<h2 id="howjavatreatsvariables">How Java Treats Variables</h2>
Let's have a refresher on how Java treats variables, as that's the key to understanding the misconception. The misconception is based on true facts, but a little warped.
<h3 id="primitivetypes">Primitive Types</h3>
Java is a statically-typed language. It requires us to first declare a variable, then initialize it, and only then can we use it:
<pre><code class="hljs">// Declaring a variable and initializing it with the value 5
int i = 5;

// Declaring a variable and initializing it with a value of false
boolean isAbsent = false;
</code></pre>
You can split up the process of declaration and initialization:
<pre><code class="hljs">// Declaration
int i;
boolean isAbsent;

// Initialization
i = 5;
isAbsent = false;
</code></pre>
But if you try to use an uninitialized variable:
<pre><code class="hljs">public static void printNumber() {
 int i;
 System.out.println(i);
 i = 5;
 System.out.println(i);
}
</code></pre>
You're greeted with an error:
<pre><code class="hljs">Main.java:10: error: variable i might not have been initialized
System.out.println(i);
</code></pre>
There are no default values for local primitive types such as <code>i</code>. Though, if you define global variables like <code>i</code> in this example:
<pre><code class="hljs">static int i;

public static void printNumber() {
 System.out.println(i);
 i = 5;
 System.out.println(i);
}
</code></pre>
Running this, you'll then see the following output:
<pre><code class="hljs">0
5
</code></pre>
The variable <code>i</code> was output as <code>0</code>, even though it wasn't yet assigned.
Each primitive type has a default value, if defined as a global variable, and these will typically be <code>0</code> for number-based types and <code>false</code> for booleans.
There are 8 primitive types in Java:
<ul>
<li><code>byte</code>: Ranges from <code>-128</code> to <code>127</code> inclusive, 8-bit signed integer</li>
<li><code>short</code>: Ranges from <code>-32,768</code> to <code>32,767</code> inclusive, 16-bit signed integer</li>
<li><code>int</code>: Ranges from <code>-2,147,483,648</code> to <code>2,147,483,647</code> inclusive, 32-bit signed integer</li>
<li><code>long</code>: Ranges from -231 to 231-1, inclusive, 64-bit signed integer</li>
<li><code>float</code>: Single precision, 32-bit <a rel="nofollow noopener" target="_blank" href="https://en.wikipedia.org/wiki/IEEE_754">IEEE 754</a> floating point integer with 6-7 significant digits</li>
<li><code>double</code>: Double precision, 64-bit IEEE 754 floating point integer, with 15 significant digits</li>
<li><code>boolean</code>: Binary values, <code>true</code> or <code>false</code></li>
<li><code>char</code>: Ranges from <code>0</code> to <code>65,536</code> inclusive, 16-bit unsigned integer representing a Unicode character</li>
</ul>
<h3 id="passingprimitivetypes">Passing Primitive Types</h3>
When we pass primitive types as method arguments, they're passed by value. Or rather, their value is copied and then passed to the method.
Let's go back to the first example and break it down:
<pre><code class="hljs">public static void main(String[] args) {
 int x = 0;
 incrementNumber(x);
 System.out.println(x);
}

public static void incrementNumber(int x) {
 x += 1;
}
</code></pre>
When we declare and initialize <code>int x = 0;</code>, we've told Java to keep a 4-byte space in the stack for the <code>int</code> to be stored in. The <code>int</code> doesn't have to fill up all 4 bytes (<code>Integer.MAX_VALUE</code>), but all 4 bytes will be available.
This spot in the memory is then referenced by the compiler when you want to use the integer <code>x</code>. The <code>x</code> variable name is what we use to access the memory location in the stack. The compiler has its own internal references to these locations.
Once we've passed <code>x</code> to the <code>incrementNumber()</code> method and the compiler reaches the method signature with the <code>int x</code> parameter - it creates a new memory location/space in the stack.
The variable name we use, <code>x</code>, has little meaning to the compiler. We can even go as far as to say that the <code>int x</code> we've declared in the <code>main()</code> method is <code>x_1</code> and the <code>int x</code> we've declared in the method signature is <code>x_2</code>.
We've then increased the value of the integer <code>x_2</code> in the method, and then print <code>x_1</code>. Naturally, the value stored in the memory location for <code>x_1</code> is printed and we see the following:
<pre><code class="hljs">0
</code></pre>
Here's a visualization of the code:
<img src="https://stackabuse.s3.amazonaws.com/media/is-java-pass-by-reference-or-pass-by-value-1.PNG" alt="java stack and primitive variables">
In conclusion, the compiler makes a reference to the memory location of primitive variables.
A stack exists for every thread we're running and it's used for static memory allocation of simple variables, as well as references to the objects in the heap (More on the heap in later sections).
This is likely what you already knew, and what everyone who answered with the initial incorrect statement know. Where the biggest misconception lies is in the next data type.
<h3 id="referencetypes">Reference Types</h3>
The type used for passing data is the reference type.
When we declare and instantiate/initialize objects (similar to primitive types), a reference is created to them - again, very similar to primitive types:
<pre><code class="hljs">// Declaration and Instantiation/initialization
Object obj = new Object();
</code></pre>
Again, we can also split this process up:
<pre><code class="hljs">// Declaration
Object obj;

// Instantiation/initialization
obj = new Object();
</code></pre>
Note: There's a difference between instantiation and initialization. Instantiation refers to the creation of the object and assigning it a location in memory. Initialization refers to the population of this object's fields through the constructor, once it's created.
Once we're done with the declaration, the <code>obj</code> variable is a reference to the <code>new</code> object in memory. This object is stored in the heap - unlike primitive types which are stored in the stack.
Whenever an object is created, it's put in the heap. The Garbage Collector sweeps this heap for objects which have lost their references and removes them as we can't reach them anymore.
The default value for objects after declaration is <code>null</code>. There is no type which <code>null</code> is an <code>instanceof</code> and it doesn't belong to any type or set. If no value is assigned to a reference, such as <code>obj</code>, the reference will point to <code>null</code>.
Let's say we have a class such as an <code>Employee</code>:
<pre><code class="hljs">public class Employee {
 String name;
 String surname;
}
</code></pre>
And instantiate the class as:
<pre><code class="hljs">Employee emp = new Employee();
emp.name = new String(&quot;David&quot;);
emp.surname = new String(&quot;Landup&quot;);
</code></pre>
Here's what happens in the background:
<img src="https://stackabuse.s3.amazonaws.com/media/is-java-pass-by-reference-or-pass-by-value-2.PNG" alt="java heap memory object creation">
The <code>emp</code> reference points to an object in the heap space. This object contains references to two <code>String</code> objects which hold the values <code>David</code> and <code>Landup</code>.
Every time the <code>new</code> keyword is used, a new object is created.
<h3 id="passingobjectreferences">Passing Object References</h3>
Let's see what happens when we pass an object as a method argument:
<pre><code class="hljs">public static void main(String[] args) {
 Employee emp = new Employee();
 emp.salary = 1000;
 incrementSalary(emp);
 System.out.println(emp.salary);
}

public static void incrementSalary(Employee emp) {
 emp.salary += 100;
}
</code></pre>
We've passed our <code>emp</code> reference to the method <code>incrementSalary()</code>. The method accesses the <code>int salary</code> field of the object and increments it by <code>100</code>. In the end, we're greeted with:
<pre><code class="hljs">1100
</code></pre>
<blockquote>
This surely means that the reference has been passed between the method call and the method itself, since the object we wanted to access has indeed been changed.
</blockquote>
Wrong. The same as with primitive types, we can go ahead and say that there are two <code>emp</code> variables once the method has been called - <code>emp_1</code> and <code>emp_2</code>, to the eyes of the compiler.
The difference between the primitive <code>x</code> we've used before and the <code>emp</code> reference we're using now is that both <code>emp_1</code> and <code>emp_2</code> point to the same object in memory.
Using any of these two references, the same object is accessed and the same information is changed.
<img src="https://stackabuse.s3.amazonaws.com/media/is-java-pass-by-reference-or-pass-by-value-3.PNG" alt="java heap memory multiple references">
That being said, this brings us to the initial question.
<h2 id="doesjavapassbyreferenceorpassbyvalue">Does Java &quot;pass-by-reference&quot; or &quot;pass-by-value&quot;?</h2>
Java passes by value. Primitive types get passed by value, object references get passed by value.
Java doesn't pass objects. It passes object references - so if anyone asks how does Java pass objects, the answer is: &quot;it doesn't&quot;.<a href="#ref-1">1</a>
In the case of primitive types, once passed, they get allocated a new space in the stack and thus all further operations on that reference are linked to the new memory location.
In the case of object references, once passed, a new reference is made, but pointing to the same memory location.
1. According to Brian Goetz, the Java Language Architect working on the Valhalla and Amber projects. You can read more about this <a target="_blank" rel="nofollow noopener" href="http://cr.openjdk.java.net/~briangoetz/valhalla/sov/02-object-model.html">here</a>.

David Landup

The question pops up a lot on the internet, and many answers are based on the misconception of how Java treats primitive and reference types. In this article, we'll debunk the misconception.

Does Java "pass-by-reference" or "pass-by-value"?

<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

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>

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.