<h2 id="introduction">Introduction</h2>
Logging, saving records to the database, and accessing files are all common tasks a programmer works on. In each of those cases, date and time play an important role in preserving the meaning and integrity of the data. Programmers often need to engage with date and time.
In this article we will learn how to get the current date and time using Python's built-in <a rel="nofollow" target="_blank" href="https://docs.python.org/3.8/library/datetime.html">datetime</a> module. With that module, we can get all relevant data in one object, or extract the date and time separately.
We will also learn how to adjust our date and time for different time zones. Finally, we'll look at converting <code>datetime</code> objects to the popular Unix or Epoch timestamps.
<h2 id="gettingthecurrentdateandtimewithdatetime">Getting the Current Date and Time with datetime</h2>
The <code>datetime</code> module contains various classes to get information about the date and time:
<ul>
<li><code>datetime.date</code>: Stores the day, month and year or a date</li>
<li><code>datetime.time</code>: Stores the time in hours, minutes, seconds, and microseconds. This information is independent from any date</li>
<li><code>datetime.datetime</code>: Stores both <code>date</code> and <code>time</code> attributes</li>
</ul>
Let's get the current date and time with a <code>datetime.datetime</code> object, as it is easier to extract <code>date</code> and <code>time</code> objects from it. First, let's import the <code>datetime</code> module:
<pre><code class="hljs">from datetime import datetime
</code></pre>
While it looks strange at first, we are getting the <code>datetime</code> class from the <code>datetime</code> module, which are two separate things.
We can use the <code>now()</code> function to get the an object with the current date and time:
<pre><code class="hljs">current_datetime = datetime.now()
print(current_datetime)
</code></pre>
Running this file will give us the following output:
<pre><code class="hljs">2019-12-13 12:18:18.290623
</code></pre>
The <code>now()</code> function gave us an object with all date and time of the moment it was created. When we print it, Python automatically formats the object to a string so it can be read by humans easily. You can read our guide on <a target="_blank" href="/how-to-format-dates-in-python/">How to Format Dates in Python</a> to learn various ways to print the time.
You can get individual attributes of the date and time like this:
<pre><code class="hljs">print(current_datetime.year) # 2019
print(current_datetime.month) # 12
print(current_datetime.day) # 13
print(current_datetime.hour) # 12
print(current_datetime.minute) # 18
print(current_datetime.second) # 18
print(current_datetime.microsecond) # 290623
</code></pre>
The <code>now()</code> method is perfect for capturing a moment. However, it is redundant when you only care about either the date or the time, but not both. How can we get date information only?
<h2 id="gettingthecurrentdate">Getting the Current Date</h2>
There are two ways to get the current date in Python. In the Python console, we can get the date from a <code>datetime</code> object with the <code>date()</code> method:
<pre><code class="hljs">&gt;&gt;&gt; from datetime import datetime
&gt;&gt;&gt; current_date = datetime.now().date()
&gt;&gt;&gt; print(current_date)
2019-12-13
</code></pre>
However, it does seem like a waste to initialize a <code>datetime</code> object only to capture the date. An alternative would be to use the <code>today()</code> method of the <code>date</code> class:
<pre><code class="hljs">&gt;&gt;&gt; from datetime import date
&gt;&gt;&gt; current_date = date.today()
&gt;&gt;&gt; print(current_date)
2019-12-13
</code></pre>
The <code>datetime.date</code> class represents a calendar date. Its <code>year</code>, <code>month</code>, and <code>day</code> attributes can be accessed in the same way we access them on the <code>datetime</code> object.
For example, this <code>print</code> statement gets each attribute, and also uses the <code>weekday()</code> method to get the day of the week:
<pre><code class="hljs">&gt;&gt;&gt; print(&quot;It&#x27;s the %dth day of the week, %dth day of the %dth month of the %dth year&quot; %
... (current_date.weekday()+1, current_date.day, current_date.month, current_date.year))
It&#x27;s the 5th day of the week, 13th day of the 12th month of the 2019th year
</code></pre>
Note: The <code>weekday()</code> method returns an integer between 0 and 6 to represent the day of the week. 0 corresponds to Monday. Therefore, in our example we added 1 in order to print the 5th day of the week (Friday), although the <code>weekday()</code> method returned 4.
Now that we can get the current date by itself, let's see how we can get the current time
<h2 id="gettingthecurrenttime">Getting the Current Time</h2>
We capture the current time from a <code>datetime</code> object using the <code>time()</code> method:
<pre><code class="hljs">&gt;&gt;&gt; from datetime import datetime
&gt;&gt;&gt; current_time = datetime.now().time()
&gt;&gt;&gt; print(current_time)
12:18:18.290623
</code></pre>
Unlike retrieving dates, there is no shortcut to capture the current time directly. The <code>datetime.time</code> class represents a notion of time as in hours, minutes, seconds and microseconds - anything that is less than a day.
Like the <code>datetime</code> object, we can access its attributes directly. Here's an example where we print the <code>current_time</code> in a sentence:
<pre><code class="hljs">&gt;&gt;&gt; print(&quot;It&#x27;s %d o&#x27;clock. To be exact, it&#x27;s %d:%d and %d seconds with %d microseconds&quot; %
... (current_time.hour, current_time.hour, current_time.minute, current_time.second, current_time.microsecond))
It&#x27;s 12 o&#x27;clock. To be exact, it&#x27;s 12:18 and 18 seconds with 290623 microseconds
</code></pre>
By default, the <code>now()</code> function returns the time of your local timezone. What if we'd need to convert it to a different one which was set in a user's preference? Let's see how we can provide timezone information to get localized <code>time</code> objects.
<h2 id="gettingthecurrentdateandtimeindifferenttimezone">Getting the Current Date and Time in Different Timezone</h2>
The <code>now()</code> method accepts a timezone as an argument, so that the <code>datetime</code> object being generated would be appropriately adjusted. First, we need to get timezone data via the <a rel="nofollow" target="_blank" href="https://pypi.org/project/pytz/">pytz</a> library.
Install the <code>pytz</code> library with <code>pip</code> if it's not available on your computer already:
<pre><code class="hljs">$ pip3 install pytz
</code></pre>
Now, let's use <code>pytz</code> to get the current date and time if we were in Berlin:
<pre><code class="hljs">&gt;&gt;&gt; import pytz
&gt;&gt;&gt; from datetime import datetime
&gt;&gt;&gt; tz = pytz.timezone(&#x27;Europe/Berlin&#x27;)
&gt;&gt;&gt; berlin_current_datetime = datetime.now(tz)
&gt;&gt;&gt; print(berlin_current_datetime)
2019-12-14 00:20:50.840350+01:00
</code></pre>
The <code>berlin_current_datetime</code> would be a <code>datetime</code> object with all the properties and functions we saw earlier, but now it perfectly matches what it is for someone who lives there.
If you would like to get the time in UTC, you can use the <code>pytz</code> module like before:
<pre><code class="hljs">&gt;&gt;&gt; import pytz
&gt;&gt;&gt; from datetime import datetime
&gt;&gt;&gt; utc_current_datetime = datetime.now(pytz.timezone(&quot;UTC&quot;))
&gt;&gt;&gt; print(utc_current_datetime)
2019-12-13 23:20:50.840350+00:00
</code></pre>
Alternatively, for UTC time you don't have to use the <code>pytz</code> module at all. The <code>datetime</code> module has a <code>timezone</code> property, which can be used like this:
<pre><code class="hljs">&gt;&gt;&gt; from datetime import datetime, timezone
&gt;&gt;&gt; utc_current_datetime = datetime.now(timezone.utc)
&gt;&gt;&gt; print(utc_current_datetime)
2019-12-13 23:20:50.840350+00:00
</code></pre>
Now that we can convert our dates and times to match different time zones, let's look at how we can convert it to one of the most widely used formats in computing - Unix timestamps.
<h2 id="convertingtimestampstodatesandtimes">Converting Timestamps to Dates and Times</h2>
Computer systems measure time based on the number of seconds elapsed since the Unix epoch, that is 00:00:00 UTC on January 1st, 1970. It's common for applications, databases, and protocols to use a timestamp in order to display time.
You can get the current timestamp in Python using the <code>time</code> library:
<pre><code class="hljs">&gt;&gt;&gt; import time
&gt;&gt;&gt; print(time.time())
1576280665.0915806
</code></pre>
The <code>time.time()</code> function returns a float number with the Unix timestamp. You can convert a timestamp to a <code>datetime</code> object using the <code>fromtimestamp()</code> function:
<pre><code class="hljs">&gt;&gt;&gt; from datetime import datetime
&gt;&gt;&gt; print(datetime.fromtimestamp(1576280665))
2019-12-13 19:44:25
</code></pre>
By default, the <code>fromtimestamp()</code> returns a <code>datetime</code> object in your timezone. You can provide a timezone as a second argument if you would like to have it localized differently.
For example, to convert a timestamp to a <code>datetime</code> object in UTC, you can do this:
<pre><code class="hljs">&gt;&gt;&gt; from datetime import datetime, timezone
&gt;&gt;&gt; print(datetime.fromtimestamp(1576280665, timezone.utc))
2019-12-13 19:44:25+00:00
</code></pre>
Conversely, you can use the <code>timestamp()</code> method to convert a <code>datetime</code> object to a valid timestamp:
<pre><code class="hljs">&gt;&gt;&gt; from datetime import datetime, timezone
&gt;&gt;&gt; print(datetime.now(timezone.utc).timestamp())
1577117555.940705
</code></pre>
<h2 id="conclusion">Conclusion</h2>
Python's built-in <code>datetime</code> library allows us to get the current date and time with the <code>now()</code> function. We can use the returned <code>datetime</code> object to extract just the date portion or the time portion. We can also get the current date with the <code>today()</code> function.
By default, Python creates <code>datetime</code> objects in our local timezone. If we utilize the <code>pytz</code> library, we can convert dates and times into different time zones.
Finally, we used the <code>fromtimestamp()</code> function to take a Unix timestamp to get a <code>datetime</code> object. If we have a <code>datetime</code> object, we can get a timestamp using its <code>timestamp()</code> method.

Marcus Sanatan

Sajjad Heydari

Logging, saving records, accessing files and tasks alike are very common. In all of them, getting the current date and time is often crucial. We can extract the current date and time using the datetime module in Python.

How to Get the Current Date and Time in Python

<h2 id="introduction">Introduction</h2>
Defining and calling functions are key practices for mastering JavaScript and most other programming languages. Usually, a function is defined before it is called in your code.
Immediately-Invoked Function Expressions (IIFE), pronounced &quot;iffy&quot;, are a common JavaScript pattern that executes a function instantly after it's defined. Developers primarily use this pattern to ensure variables are only accessible within the scope of the defined function.
In this article, you will first learn about function expressions. Afterwards, we will go further in-depth into IIFEs - how to write them and when to use them. Finally, we'll discuss how the <code>let</code> keyword introduced in ECMAScript 6 provides a cleaner alternative for some IIFE use-cases.
<h2 id="whatarefunctionexpressions">What are Function Expressions?</h2>
In JavaScript, you can define a function in 2 different ways:
<ol>
<li>A declaration</li>
<li>An expression</li>
</ol>
Function Declarations begin with the <code>function</code> keyword, followed by the name of the function and any arguments it may take. For example, we can create a <code>logName</code> function using a declaration like this:
<pre><code class="hljs">function logName(userName) {
 console.log(`${userName}, you are awesome`);
};

logName(&quot;Jane&quot;);
</code></pre>
From the function's definition, we log any given value in the <code>message</code> parameter to the console. We then called the function with &quot;Jane, you are awesome!&quot;, which will print that text to the console.
When defining a function using function declarations, the function is hoisted. A hoisted function or variable is placed at the top of their functional scope when JavaScript is executing code.
<blockquote>
Note: Functional Scope refers to where a function was defined. For example, if a function <code>foo()</code> contained a function <code>bar()</code> inside of it, we would say that the functional scope of <code>bar()</code> is <code>foo()</code>. If <code>foo()</code> was not defined within a function, then <code>foo()</code> belongs to the global scope. JavaScript functions in the global scope are accessible to all the code that runs with it.
</blockquote>
In practice, this behavior allows you to use a function before defining it. For example, the previous code can be rewritten like this and would behave the same way:
<pre><code class="hljs">logName();

function logName(name) {
 console.log(`${name}, you are awesome!`);
};
</code></pre>
Function Expressions are functions definitions that are assigned to a variable. Therefore, our <code>logName()</code> function declaration can become a function expression if we created it like this:
<pre><code class="hljs">const logUserName = function logName(name) {
 console.log(`${name}, you are awesome!`);
};

logUserName(&quot;Jane&quot;);
</code></pre>
In this example, to call the function we need to use the variable name that was provided - <code>logUserName</code>. This does not change the behavior of the function, it still logs &quot;You are awesome&quot; to the console.
Unlike function declarations, function expressions are not hoisted. These functions are only available when the JavaScript interpreter processes that line of code.
For example, if we tried to call <code>logUserName()</code> before creating it as a function expression:
<pre><code class="hljs">logUserName(&quot;Jane&quot;);
const logUserName = function logName(name) {
 console.log(`${name}, you are awesome!`);
};
</code></pre>
We get the following error:
<pre><code class="hljs">Uncaught ReferenceError: Cannot access 'logUserName' before initialization
</code></pre>
Another difference between function expressions and function declarations is that function expressions can define functions without a name.
Functions without names are called anonymous functions. For example, <code>logUserName()</code> could also be defined with an anonymous function like this:
<pre><code class="hljs">const logUserName = function (name) {
 console.log(`${name}, you are awesome!`);
};
</code></pre>
<h3 id="arrowfunctions">Arrow Functions</h3>
Arrow functions provide syntactic sugar for Function Expressions. A re-implementation of our <code>logUserName</code> function using an arrow function would look like this:
<pre><code class="hljs">const logUserName = (name) =&gt; {
 console.log(`${name}, you are awesome!`);
}
</code></pre>
Read <a target="_blank" href="/arrow-functions-in-javascript">Arrow Functions in JavaScript</a> to learn more about this syntax, and how it affects function scope.
Now that we know how to create various function expressions, let's learn how to immediately invoke them.
<h2 id="whatareimmediatelyinvokedfunctionexpressions">What are Immediately-Invoked Function Expressions?</h2>
IIFEs are functions that are executed immediately after being defined.
We can make any function expression an IIFE by wrapping it in parentheses, and adding a following pair of parentheses at the end:
<pre><code class="hljs">(function() {
 // Code that runs in your function
})()
</code></pre>
Alternatively, you can use the arrow syntax to create an IIFE as follows:
<pre><code class="hljs">(() =&gt; {
 // Code that runs in your function
})()
</code></pre>
The parentheses surrounding the function definition lets JavaScript know that it will process a function expression. The last pair of parentheses invoke the function.
<h3 id="syntaxvariations">Syntax Variations</h3>
You can create IIFEs without the first set of parentheses if you use a unary operator - special characters that tell JavaScript to evaluate the following expression.
We can create function expressions with unary operators like this:
<pre><code class="hljs">+function () {
 // Code that runs in your function
}();

-function () {
 // Code that runs in your function
}();

!function () {
 // Code that runs in your function
}();

~function () {
 // Code that runs in your function
}();

void function () {
 // Code that runs in your function
}();
</code></pre>
It's important to note that these operators could affect any data returned by your function. For example, the code below looks like it should return <code>10</code>, but it actually returns <code>-10</code>:
<pre><code class="hljs">$ node
&gt; -function () {return 10;}();
-10
&gt;
</code></pre>
Since this unary syntax is less common and can be confusing to developers, it is generally discouraged.
IIFEs can also take functional arguments. We can pass variables into the scope as shown below:
<pre><code class="hljs">(function(arg1, arg2) {
 // Code that runs in your function
})(&quot;hello&quot;, &quot;world&quot;);
</code></pre>
Now that we have seen how to create IIFEs, let's look at common situations where they are used.
<h2 id="whentouseaniife">When to Use an IIFE?</h2>
The most common use cases for IIFEs are:
<ul>
<li>Aliasing global variables</li>
<li>Creating private variables and functions</li>
<li>Asynchronous functions in loops</li>
</ul>
<h3 id="aliasingglobalvariables">Aliasing Global Variables</h3>
If you have 2 libraries that export an object with the same name, you can use IIFEs to ensure they don't conflict in your code. For example, the <a rel="nofollow" target="_blank" href="https://jquery.com/">jQuery</a> and <a rel="nofollow" target="_blank" href="https://kenwheeler.github.io/cash/">Cash</a> JavaScript libraries both export <code>$</code> as their main object.
You can wrap your code within an IIFE that passes one of the global variables as an argument. Let's say, we want to ensure that <code>$</code> refers to the <code>jQuery</code> object, and not the <code>cash</code> alternative. You can ensure that <code>jQuery</code> is used with the following IIFE:
<pre><code class="hljs">(function($) {
 // Code that runs in your function
})(jQuery);
</code></pre>
<h3 id="creatingprivatevariablesandfunctions">Creating Private Variables and Functions</h3>
We can use IIFEs to create private variables and functions within the global scope, or any other function scope.
Functions and variables added to the global scope are available to all scripts that are loaded on a page. Let's say we had a function <code>generateMagicNumber()</code>, which returned a random number between 900 and 1000 inclusive, and a variable <code>favoriteNumber</code> in our JavaScript file.
We can write them like this:
<pre><code class="hljs">function generateMagicNumber() {
 return Math.floor(Math.random() * 100) + 900;
}

console.log(&quot;This is your magic number: &quot; + generateMagicNumber());

var favoriteNumber = 5;
console.log(&quot;Twice your favorite number is &quot; + favoriteNumber * 2);
</code></pre>
If we load other JavaScript files in our browser, they also gain access to <code>generateMagicNumber()</code> and <code>favoriteNumber</code>. To prevent them from using or editing them, we en-case our code in an IIFE:
<pre><code class="hljs">(function () {
 function generateMagicNumber() {
 return Math.floor(Math.random() * 100) + 900;
 }

 console.log(&quot;This is your magic number: &quot; + generateMagicNumber());

 var favoriteNumber = 5;
 console.log(&quot;Twice your favorite number is &quot; + favoriteNumber * 2);
})();
</code></pre>
It runs the same, but now <code>generateMagicNumber()</code> and <code>favoriteNumber</code> are only accessible in our script.
<h3 id="asynchronousfunctionsinloops">Asynchronous Functions in Loops</h3>
JavaScript's behavior surprises many when callbacks are executed in loops. For example, let's count from 1 to 5 in JavaScript, putting a 1 second gap between every time we log a message. A naive implementation would be:
<pre><code class="hljs">for (var i = 1; i &lt;= 5; i++) {
 setTimeout(function () {
 console.log(&#x27;I reached step &#x27; + i);
 }, 1000 * i);
}
</code></pre>
If you run this code, you will get the following output:
<pre><code class="hljs">$ node naiveCallbackInLoop.js
I reached step 6
I reached step 6
I reached step 6
I reached step 6
I reached step 6
</code></pre>
While the output would be printed 1 second after the other, each line prints that they reached step 6. Why?
When JavaScript encounters asynchronous code, it defers execution of the callback until the asynchronous task completes. That's how it remains non-blocking. In this example, the <code>console.log()</code> statement will run only after the timeout has elapsed.
JavaScript also created a closure for our callback. Closures are a combination of a function and its scope when it was created. With closures, our callback can access the variable <code>i</code> even though the <code>for</code> loop has already finished executing.
However, our callback only has access to the value of <code>i</code> at the time of its execution. As the code within the <code>setTimeout()</code> function were all deferred, the <code>for</code> loop was finished with <code>i</code> being equal to 6. That's why they all log that they reached step 6.
This problem can be solved with an IIFE:
<pre><code class="hljs">for (var i = 1; i &lt;= 5; i++) {
 (function (step) {
 setTimeout(function() {
 console.log(&#x27;I reached step &#x27; + step);
 }, 1000 * i);
 })(i);
}
</code></pre>
By using an IIFE, we create a new scope for our callback function. Our IIFE takes a parameter <code>step</code>. Every time our IIFE is called, we give it the current value of <code>i</code> as its argument. Now, when the callback is ready to be executed, its closure will have the correct value of <code>step</code>.
If we run this code snippet, we will see the following output:
<pre><code class="hljs">$ node iifeCallbackInLoop.js
I reached step 1
I reached step 2
I reached step 3
I reached step 4
I reached step 5
</code></pre>
While IIFEs solves our problem with minimal code changes, let's have a look at how ES6 features can make it easier to run asynchronous code in loops.
<h2 id="blockscopingwithletandconst">Block Scoping with <code>let</code> and <code>const</code></h2>
ES6 added the <code>let</code> and <code>const</code> keywords to create variables in JavaScript. Variables declared with <code>let</code> or <code>const</code> are block-scoped. This means that they can only be accessed within their enclosing block - a region enclosed by curly braces <code>{ }</code>.
Let's count from 1-5 in 1 second intervals using the <code>let</code> keyword instead of <code>var</code>:
<pre><code class="hljs">for (let i = 1; i &lt;= 5; i++) {
 setTimeout(function () {
 console.log(&#x27;I reached step &#x27; + i);
 }, 1000 * i);
}
</code></pre>
We will get the following output when we run this code:
<pre><code class="hljs">$ node es6CallbackInLoop.js
I reached step 1
I reached step 2
I reached step 3
I reached step 4
I reached step 5
</code></pre>
Now that the variable <code>i</code> is block-scoped, the closures for our callback function get the appropriate value of <code>i</code> when they eventually execute. This is more concise than our IIFE implementation.
Using <code>let</code> is the preferred way to execute asynchronous functions in a loop,
<h2 id="conclusion">Conclusion</h2>
An Immediately-Invoked Function Expression (IIFE) is a function that is executed instantly after it's defined. This pattern has been used to alias global variables, make variables and functions private and to ensure asynchronous code in loops are executed correctly.
While popular, we have seen how changes in ES6 can eliminate the need to use IIFEs in modern JavaScript. However, mastering this pattern also gives us a deeper understanding of scope and closure, and will be especially useful in maintaining legacy JavaScript code.

Allan Mogusu

Immediately Invoked Function Expressions (IFFE) are a common JavaScript pattern that executes a function instantly upon definition, as opposed to calling it afterwards.

JavaScript's Immediately Invoked Functions

JavaScript's Immediately Invoked Function Expressions

Robley Gori

Redis is an in-memory data structure store, often used as a database, cache or message broker. In this article, we'll expore Redis as a key-value store and use it in a Python project with Django.

Working with Redis in Python with Django

<h2 id="introduction">Introduction</h2>
There are numerous free hosting services available for getting your Node.js applications up and running publicly. One of these services is <a rel="nofollow" target="_blank" href="https://www.heroku.com/">Heroku</a>, that allows you to deploy, manage and scale your applications on the web.
In this article we'll be building a simple Node and Express.js application that shortens given links, and deploy it to Heroku.
<h2 id="creatinganodejsurlshortener">Creating a Node.js URL Shortener</h2>
To make the development process easier we'll be using <a rel="nofollow" target="_blank" href="https://expressjs.com">Express</a>, which is a lightweight web framework that is flexible and easily customizable. Express comes with an <a rel="nofollow" target="_blank" href="https://expressjs.com/en/starter/generator.html">application generator</a>, but we'll start from scratch.
<h3 id="creatingtheprojectdirectory">Creating the Project Directory</h3>
Let's <code>cd</code> into the workspace and create a new directory for the project:
<pre><code class="hljs">$ mkdir url-shortener
</code></pre>
<h3 id="initializingnpm">Initializing npm</h3>
Next let's initialize <a rel="nofollow" target="_blank" href="https://www.npmjs.com">npm</a>, and with it, start our project:
<pre><code class="hljs">$ npm init
</code></pre>
<code>npm init</code> will ask a series of questions (package name, version, description, etc). For simplicity's sake, let's skip all of these by hitting <kbd>RETURN</kbd> for each prompt. Node will then generate a <code>package.json</code> file and print it to the terminal:
<pre><code class="hljs">{
 &quot;name&quot;: &quot;url-shortener&quot;,
 &quot;version&quot;: &quot;1.0.0&quot;,
 &quot;description&quot;: &quot;&quot;,
 &quot;main&quot;: &quot;index.js&quot;,
 &quot;scripts&quot;: {
 &quot;start&quot;: &quot;node app.js&quot;,
 &quot;test&quot;: &quot;echo \&quot;Error: no test specified\&quot; &amp;&amp; exit 1&quot;
 },
 &quot;author&quot;: &quot;&quot;,
 &quot;license&quot;: &quot;ISC&quot;,
}
</code></pre>
The fields in <code>package.json</code> (package name, description, author, etc) can be updated at any time so you don't need to worry about it too much.
What we've added here manually is the <code>&quot;start&quot;: &quot;node app.js&quot;</code>. This will be extremely important later, when we deploy the app to Heroku.
Heroku needs to know how to run our application, and this is typically done via a Procfile. Since our application is so simple, a Procfile would be overkill, and it's enough to simply define that our app should be run by simply executing the <code>node app.js</code> command.
<h3 id="installingexpress">Installing Express</h3>
With that out of the way, we're ready to install Express:
<pre><code class="hljs">$ npm install express --save
</code></pre>
<h3 id="buildinganodeserver">Building a Node Server</h3>
With Express installed I'll create a very simple application in a file called <code>app.js</code>:
<pre><code class="hljs">const express = require(&#x27;express&#x27;);
const app = express();
const path = require(&#x27;path&#x27;);
const port = 3000;

app.get(&#x27;/&#x27;, function(req, res) {
 res.sendFile(path.join(__dirname + &#x27;/index.html&#x27;));
});

app.listen(port, () =&gt; console.log(`url-shortener listening on port ${port}!`));
</code></pre>
The application at this point is really only the Express boilerplate required to set it up, with a single route handler that returns an HTML page on port <code>3000</code>.
Let's go ahead and define the page, which will accept a URL we want to shorten. It'll only consist of a header and a simple form that accepts the URL:
<pre><code class="hljs">&lt;h1&gt;URL Shortener&lt;/h1&gt;

&lt;form method=&quot;POST&quot; action=&quot;/url&quot;&gt;
 &lt;input type=&quot;text&quot; name=&quot;url&quot; /&gt;
 &lt;input type=&quot;submit&quot; /&gt;
&lt;/form&gt;
</code></pre>
We can test if the application is running fine by executing:
<pre><code class="hljs">$ node app.js
</code></pre>
Since we've added the <code>&quot;start&quot; : &quot;node app.js&quot;</code> command to our <code>package.json</code> file, we can also run it using an NPM command:
<pre><code class="hljs">$ npm start
</code></pre>
And navigating to <code>http://localhost:3000</code>:
<img src="https://stackabuse.s3.amazonaws.com/media/deploying-a-node-app-to-heroku-1.png" alt="application homepage">
<h3 id="handlingformsubmission">Handling Form Submission</h3>
While the page is rendering correctly, there's no logic to actually handle the POST request sent via the form at the <code>/url</code> endpoint.
To snatch the URL from the request sent via the form, we'll be using the <a rel="nofollow" target="_blank" href="https://www.npmjs.com/package/body-parser">body-parser</a> module and extract it from the request body, so let's go ahead and <code>require</code> it as well and set it up for use:
<pre><code class="hljs">const bodyParser = require(&#x27;body-parser&#x27;);
app.use(bodyParser.urlencoded({extended: true}));
app.use(express.urlencoded());
</code></pre>
With that done, we can extract the body of the request via <code>req.body</code> so let's go ahead and make another request handler that packs the URL from the body and sends it back via the response:
<pre><code class="hljs">app.post(&#x27;/url&#x27;, function(req, res) {
 const url = req.body.url;

 res.send(url);
});
</code></pre>
This still isn't what we want as we're getting the entire URL back and not the shortened version.
<h3 id="shorteningtheurl">Shortening the URL</h3>
The only thing left to do for our Node app to be complete is to actually shorten the URL before sending it back. For this, we can use the <a rel="nofollow" target="_blank" href="https://www.npmjs.com/package/node-url-shortener">node-url-shortener</a> module. Let's install it via npm:
<pre><code class="hljs">$ npm install node-url-shortener --save
</code></pre>
Then require the package in the application:
<pre><code class="hljs">const urlShortener = require(&#x27;node-url-shortener&#x27;);
</code></pre>
And lastly, let's add another block of code that shortens the URL before sending it back:
<pre><code class="hljs">app.post(&#x27;/url&#x27;, function(req, res) {
 const url = req.body.url;

 urlShortener.short(url, function(err, shortUrl){
 res.send(shortUrl);
 });
});
</code></pre>
The <code>urlShortner</code> has a <code>short()</code> method that accepts two parameters: the original URL and a callback function. The shortened URL gets passed into the callback function and then into <code>res.send()</code>.
Let's start up the application and test it out:
<img src="https://stackabuse.s3.amazonaws.com/media/deploying-a-node-app-to-heroku-3.png" alt="input url">
After inputting a URL, we're greeted with:
<img src="https://stackabuse.s3.amazonaws.com/media/deploying-a-node-app-to-heroku-2.png" alt="url shortener result">
<h2 id="deployingtoheroku">Deploying to Heroku</h2>
<h3 id="signingupforherokuandinstallingthecli">Signing up for Heroku and Installing the CLI</h3>
Now that the application has been built, it's time to think about Heroku. If you don't have an account, head over to <a rel="nofollow" target="_blank" href="https://signup.heroku.com">signup.heroku.com</a> and create one.
Once you have an account, the next thing to do is install Heroku's CLI tools, which are used for deployment. Heroku provides installation instructions at <a rel="nofollow" target="_blank" href="https://devcenter.heroku.com/articles/heroku-cli#download-and-install">The Dev Center</a>.
<h3 id="pushingtoheroku">Pushing to Heroku</h3>
Deploying to Heroku works via <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Git">Git</a>. It's very simple once you understand how it works. In essence you can deploy to Heroku by pushing to a remote repo, just like pushing to GitHub.
Because this is a new project, Git needs to be initialized:
<pre><code class="hljs">$ git init
</code></pre>
Now, we're ready to add and commit all the project files. Though, before doing that, we'll add a <code>.gitignore</code> file because we don't want the <code>node_modules</code> directory to be committed. It should be generated by npm upon deployment rather than committed to source control.
In your <code>.gitignore</code> file, simply add:
<pre><code class="hljs">node_modules
</code></pre>
With that out of the way, we can add and commit:
<pre><code class="hljs">$ git add .
$ git commit -m &#x27;initial commit&#x27;
</code></pre>
Once the project is committed, we need to create a Heroku app that'll correspond to our Node app:
<pre><code class="hljs">$ heroku create
Creating app... !
 ▸ Invalid credentials provided.
heroku: Press any key to open up the browser to login or q to exit:
Opening browser to https://cli-auth.heroku.com/auth/browser/abcd1234-b6a7-4df4-bb42-0eaf987d0637
Logging in... done
Logged in as example@gmail.com
Creating app... done, ⬢ nameful-wolf-12818
https://nameful-wolf-12818.herokuapp.com/ | https://git.heroku.com/nameful-wolf-12818.git
</code></pre>
If this is your first time using the CLI, Heroku will ask you to login via the browser. The process is very simple, just follow the instructions.
Once complete, Heroku returns the newly created app name and URL (your app name will be different to mine). If you browse to the URL you'll see a Heroku welcome page.
This still isn't our URL shortener app, simply a public Heroku app to which we'll deploy our own.
<h3 id="deployingtheapp">Deploying the App</h3>
In the previous <code>heroku create</code> command, a new remote will have been added to your Git repository, allowing you to deploy to Heroku with a simple command like this:
<pre><code class="hljs">$ git push heroku master
Enumerating objects: 5, done.
Counting objects: 100% (5/5), done.
Delta compression using up to 4 threads
Compressing objects: 100% (3/3), done.
Writing objects: 100% (3/3), 326 bytes | 326.00 KiB/s, done.
Total 3 (delta 2), reused 0 (delta 0)
...
...
...
remote: Verifying deploy... done.
To https://git.heroku.com/nameful-wolf-12818.git
 5cb9118..dd0bacd master -&gt; master
</code></pre>
Since the application is successfully deployed, we can go ahead and start it up:
<img src="https://stackabuse.s3.amazonaws.com/media/deploying-a-node-app-to-heroku-4.png" alt="deployed application on heroku">
Though, we'll encounter an issue due to the mismatch in ports. In our app, we've hardcoded that it uses port <code>3000</code>, but Heroku works on a different port and this clash crashes our application.
In order to make the application work both locally and on Heroku, we'll change the port to be either <code>3000</code> or the <code>process.env.PORT</code>, which is set by Heroku:
<pre><code class="hljs">const port = process.env.PORT || 3000;
</code></pre>
Deploying the application again and refreshing the page, everything works just fine!
<img src="https://stackabuse.s3.amazonaws.com/media/deploying-a-node-app-to-heroku-5.png" alt="heroku deployed application homepage">
<img src="https://stackabuse.s3.amazonaws.com/media/deploying-a-node-app-to-heroku-6.png" alt="heroku deployed application result page">
<h2 id="conclusion">Conclusion</h2>
There are numerous free hosting services available for getting your applications up and running publicly. One of these services is <a rel="nofollow" target="_blank" href="https://www.heroku.com/">Heroku</a>, that allows you to deploy, manage and scale your applications on the web.
We've built a simple Node and Express application that shortens provided URLs via the <code>node-url-shortener</code> module. We've then prepared that app for deployment and finally got it up and running on Heroku.

Tom Kadwill

Heroku allows us to easily deploy, scale and get applications public on the web.
In this article, we'll build a Node/Express application and deploy it to Heroku.

Deploying a Node.js App to Heroku

<h2 id="introduction">Introduction</h2>
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 is part of the Amazon Web Services (AWS) platform - <a rel="nofollow" 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' other services are built on top of it - therefore it's good to get an understanding of what EC2 is and how to deploy 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. At the end of this tutorial you'll have your Node app running on AWS, and a better understanding of how to interact with a core AWS service.
<h2 id="prerequisites">Prerequisites</h2>
<h3 id="awsaccount">AWS Account</h3>
<a rel="nofollow" target="_blank" href="https://aws.amazon.com/">Amazon Web Services</a> (AWS) is a collection of tools for building applications in the cloud. As EC2 is an AWS service, we'll need to set up an AWS account.
AWS has a free tier for a lot of awesome stuff, and EC2 is no exception - you're free to use 750 hours (31 days) of EC2 a month in the free tier for a whole year.
<h3 id="docker">Docker</h3>
<a rel="nofollow" target="_blank" href="https://www.docker.com/">Docker</a> allows us to bundle up our applications into small, easily deployable units that can be run anywhere where Docker is installed. This means no more of that 'but it works on my machine!'
This article will assume basic familiarity with Docker, and won't be going into any depth on it - however, if you'd like to do a deeper dive then check out <a target="_blank" href="/deploying-a-node-js-app-to-a-digitalocean-droplet-with-docker/">Deploying a Node.js App to a DigitalOcean Droplet with Docker</a>.
<h2 id="nodeapplication">Node Application</h2>
Let's make a really simple Node application that responds to a request. To do this, we'll open up a terminal and run:
<pre><code class="hljs">$ mkdir node-ec2
$ cd node-ec2
$ npm init
</code></pre>
This will create a new folder, move into that folder, and then initialize a new Node application.
Let's stick with the NPM defaults for now - this article will assume you left the entry point as <code>index.js</code>. This will generate our <code>package.json</code> file, which is essentially a configuration file for our app.
Once the <code>package.json</code> file is created, open it up and add the following line to the beginning of the <code>scripts</code> section:
<pre><code class="hljs">&quot;start&quot;: &quot;node index.js&quot;,
</code></pre>
By doing this, instead of running <code>node index.js</code>, we'll be using <code>npm start</code>, which will run everything in our script. In this specific case, it just runs <code>node index.js</code>, though in reality, it could be much more than that. For example, if we can add flags to the command without having to type it out each time, or we could set some environment variables like <code>NODE_ENV=production node index.js</code>.
To serve our requests, we're going to be using the <a rel="nofollow" target="_blank" href="https://expressjs.com">Express</a> framework - it's minimalistic, and easy to get started with:
<pre><code class="hljs">$ npm install express --save
</code></pre>
Our <code>package.json</code> should now look something like this:
<pre><code class="hljs">{
 &quot;name&quot;: &quot;app&quot;,
 &quot;version&quot;: &quot;1.0.0&quot;,
 &quot;description&quot;: &quot;&quot;,
 &quot;main&quot;: &quot;index.js&quot;,
 &quot;scripts&quot;: {
 &quot;start&quot;: &quot;node index.js&quot;
 },
 &quot;author&quot;: &quot;&quot;,
 &quot;license&quot;: &quot;ISC&quot;,
 &quot;dependencies&quot;: {
 &quot;express&quot;: &quot;^4.17.1&quot;
 }
}
</code></pre>
Wait for the install, and then we're going to open our preferred code editor to create another new file in the same location called <code>index.js</code>.
The file will set up Express and define a request handler:
<pre><code class="hljs">const express = require(&#x27;express&#x27;);
const app = express();
const port = 3000;

app.get(&#x27;/status&#x27;, (req, res) =&gt; res.send({status: &quot;I&#x27;m alive!&quot;}));

app.listen(port, () =&gt; console.log(`Example app listening on port ${port}!`));
</code></pre>
This app will start on port <code>3000</code>, and will serve an endpoint at <code>/status</code>. We can verify this works by running:
<pre><code class="hljs">$ npm start
Example app listening on port 3000!
</code></pre>
Heading to <code>http://localhost:3000/status</code> - we should get a response back with <code>{status: &quot;I'm alive!&quot;}</code>. Once that's successful, make sure to stop the server with <kbd>CTRL</kbd>+<kbd>C</kbd>.
With our simple Node application ready, let's turn it into a Docker image which we'll deploy to EC2.
<h3 id="dockerizingthenodeapplication">Dockerizing the Node Application</h3>
Create a new file in the same directory as your Node application, called <code>Dockerfile</code>:
<pre><code class="hljs">FROM node:13-alpine

WORKDIR /usr/src/app

COPY package*.json ./

RUN npm install

COPY . .

EXPOSE 3000
CMD [ &quot;node&quot;, &quot;index.js&quot; ]
</code></pre>
This is a basic Dockerfile that can be used for most simple Node applications. Next, let's build the Docker image and then run it to verify it's working correctly:
<pre><code class="hljs">$ docker build . -t ec2-app
$ docker run -p 3000:3000 ec2-app
</code></pre>
If you navigate to <code>http://localhost:3000/status</code> again, you should see the same status response from earlier. Exit the process with <kbd>CTRL</kbd>+<kbd>C</kbd> again.
Finally, let's push our Docker image to <a rel="nofollow" target="_blank" href="https://hub.docker.com/">Docker Hub</a>:
<pre><code class="hljs">$ docker login # Use your Docker Hub credentials here
$ docker tag ec2-app &lt;YOUR_DOCKER_USERNAME&gt;/ec2-app
$ docker push &lt;YOUR_DOCKER_USERNAME&gt;/ec2-app
</code></pre>
<h2 id="settingupec2">Setting up EC2</h2>
With our application &quot;dockerized&quot;, we need to set up an EC2 instance for it to run on.
Head to AWS and log in.
Click the 'Services' dropdown menu at the top of the page, and search for 'EC2'. AWS is currently experimenting with their interface, so you should see a page that looks something like the one below, but the center of the page may look slightly different.
Click on the 'Instances' link on the left.
<img src="https://stackabuse.s3.amazonaws.com/media/getting-started-with-aws-ec2-with-nodejs-1.png" alt="EC2 Welcome Page">
On the next view, click the 'Launch Instance' button. You'll see a page that looks like this:
<img src="https://stackabuse.s3.amazonaws.com/media/getting-started-with-aws-ec2-with-nodejs-2.png" alt="EC2 AMI Selection">
<h3 id="amis">AMIs</h3>
This is where we select the Amazon Machine Image - or AMI for short. An AMI is an 'out of the box' server, and can come with multiple configurations.
For instance, we could select one of the Quick Start AMIs that have <a rel="nofollow" target="_blank" href="https://aws.amazon.com/amazon-linux-2/">Amazon Linux 2</a> on them, or if you scroll down, there are instances with Ubuntu running on them, etc.
Each AMI is a frozen image of a machine with an operating system and potentially some extra software installed.
To make things easy, we can use this to build an EC2 instance with Docker already configured for us!
To do this, we need to select 'AWS Marketplace' on the left, and then in the search box we want to enter 'ECS'. We should get a few results, but we want the 'ECS Optimized Amazon Linux 2' image.
This image comes with Docker, and is optimized for running containers. Hit 'Select' on the chosen image and we'll continue to the next page:
<img src="https://stackabuse.s3.amazonaws.com/media/getting-started-with-aws-ec2-with-nodejs-3.png" alt="Choosing an AMI">
<h3 id="instancetypes">Instance Types</h3>
On the next view, we select what type of instance we want. Generally, this dictates the resources available to the server that we're starting up, with scaling costs for more performant machines.
The <code>t2.micro</code> instance type is eligible for free tier, so it's recommended to use that:
<img src="https://stackabuse.s3.amazonaws.com/media/getting-started-with-aws-ec2-with-nodejs-4.png" alt="Selecting EC2 instance type">
Select the appropriate checkbox, and then click 'Review and Launch' in the bottom right corner. Click 'Launch' in the same place on the next page, and you'll get a pop-up to select or create a key-pair.
Select the first drop-down, and select 'Create a new key pair'. Under 'Key pair name', enter what you want to call your key pair.
Make sure to 'Download the Key Pair' on the right hand side - this is what we'll use to access our EC2 instance.
By selecting 'Launch Instance' again, your EC2 instance should get started up:
<img src="https://stackabuse.s3.amazonaws.com/media/getting-started-with-aws-ec2-with-nodejs-5.png" alt="Launching instance">
Click the highlighted link to be taken to the instance detail page.
<h3 id="securitygroups">Security Groups</h3>
Before we try running our application, we need to make sure that we'll be able to access the application.
Most AWS resources operate under 'Security Groups' - these groups dictate how resources can be accessed, on what port, and from which IP addresses.
Click the security group highlighted here:
<img src="https://stackabuse.s3.amazonaws.com/media/getting-started-with-aws-ec2-with-nodejs-6.png" alt="Security Group Link">
From here, you'll be able to see details about the security group, including it's inbound and outbound rules in various tabs. Under the inbound tab, you'll hopefully see this:
<img src="https://stackabuse.s3.amazonaws.com/media/getting-started-with-aws-ec2-with-nodejs-7.png" alt="Inbound rules">
What this means is that traffic that comes in through port <code>22</code>, using the TCP protocol, is allowed from anywhere (<code>0.0.0.0/0</code> meaning anywhere). We need to add another rule to allow anybody to access our app at port <code>3000</code>.
At the top of the page, click 'Actions' and then click 'Edit inbound rules'. In the dialog that opens, click 'Add rule'.
Set the port range of the rule to <code>3000</code>, and under Source, click the drop-down and select 'Anywhere'. The rest should be automatically populated.
Ultimately, you should end up with something like:
<img src="https://stackabuse.s3.amazonaws.com/media/getting-started-with-aws-ec2-with-nodejs-9.png" alt="Editing the inbound rules">
<h3 id="connectingtoyourec2instance">Connecting to Your EC2 Instance</h3>
Head back to the 'Instances' page (click the link on the left) and select the instance you created earlier. The address for your EC2 instance is located above the link to the security groups under the 'Public DNS' field.
Head back to the terminal, and navigate to the folder where the key-pair you downloaded earlier is located. It will be named as whatever you entered for the key-pair name, with a <code>.pem</code> as its extension.
Let's change the key's permissions and then SSH into the EC2 instance:
<pre><code class="hljs">$ chmod 400 &lt;NAME_OF_KEYPAIR_FILE&gt;
$ ssh -i &lt;NAME_OF_KEYPAIR_FILE&gt;ec2-user@&lt;PUBLIC_DNS&gt;
</code></pre>
From here, we just need to launch our app via Docker:
<pre><code class="hljs">$ docker run -p 3000:3000 &lt;YOUR_DOCKER_USERNAME&gt;/ec2-app
</code></pre>
You'll be able to reach the instance using the same address you used to SSH into the instance. Simply navigate in your browser to:
<pre><code class="hljs">&lt;PUBLIC_DNS&gt;:3000/status
</code></pre>
Your app should return the status endpoint to you that we saw earlier. Congratulations, you've just run your first app on EC2!
<h2 id="whatnext">What Next?</h2>
<h3 id="runyourappheadlessly">Run Your App Headlessly</h3>
A quick win, however, is to run the app &quot;headless&quot;. As of now, your app is currently running in your shell session - and as soon as you close that session, the app will terminate!
To start the app in a way that it'll keep running in the background, run the app with the additional <code>-d</code> flag:
<pre><code class="hljs">$ docker run -d -p 3000:3000 &lt;YOUR_DOCKER_USERNAME&gt;/ec2-app
</code></pre>
<h3 id="security">Security</h3>
You might want to go back and tighten up the security on the instance/experiment with different configurations - such as configuring it so that only we can access the SSH port, for example.
Change the 'Source' field on the first rule to 'My IP' - AWS will automatically figure out where you're accessing it from.
Note: If you're running through this tutorial on the move, or come back to it later, your computer might have a different IP than when you initially set 'My IP'. If you encounter any difficulties later on, make sure to come back here and select 'My IP' again!
<h3 id="otheramis">Other AMIs</h3>
There are hundreds of different AMIs, a lot from various communities, with applications already pre-installed - it's worth taking a look through to see if there's an easy way to set up something you've wanted to work with!
<h3 id="addingadomain">Adding a Domain</h3>
Now that you've got an app running on a server, you might want to set up a domain name and point that at your application.
<h2 id="conclusion">Conclusion</h2>
EC2 really is the backbone of a lot of AWS services - for instance, RDS (AWS' database service) is really just heavily optimized EC2 instances with a nice dashboard.
Understanding this core product in AWS' arsenal is bound to open doors to new ways of implementing ideas.
In this tutorial, we've created a simple Node.js application with the help of Express, dockerized it, set up EC2 for deployment and finally - deployed it to the EC2 instance.

Josh Simpson

AWS EC2 is a core service and a foundation for many other services. In this article, we'll be building a Node app with Docker, setting up an EC2 instance and deploying our app to it.

Deploying Node.js Apps to AWS EC2 with Docker

<h2 id="introduction">Introduction</h2>
System administrators and developers frequently turn to automation to reduce their workload and improve their processes. When working with servers, automated tasks are frequently scripted with shell scripts. However, a developer might prefer to use a more general higher-level language for complex tasks. Many applications also need to interact with the file system and other OS-level components, which is often more easily done with command line level utilities.
With Node.js, we can run shell commands and process their inputs and outputs using JavaScript. Therefore, we can write most of these complex operations in JavaScript instead of the shell scripting language, potentially making the program easier to maintain.
In this article, we will learn the various ways to execute shell commands in Node.js using the <code>child_process</code> module.
<h2 id="thechild_proccessmodule">The child_proccess Module</h2>
Node.js executes its main event loop in a single thread. However, that does not mean that all of its processing is done in that one thread. Asynchronous tasks in Node.js are executed in other internal threads. When they are complete, the code in the callback, or error, is returned to the main, single thread.
These various threads are run in the same Node.js process. However, it is sometimes desirable to create another process to execute code. When a new process is created, the Operating System determines which processor it uses and how to schedule its tasks.
The <code>child_process</code> module creates new child processes of our main Node.js process. We can execute shell commands with these child processes.
Using external processes can improve performance of your application if used correctly. For example, if a feature of a Node.js application is CPU intensive, as Node.js is single threaded it would block the other tasks from executing while it is running.
However, we can delegate that resource intensive code to a child process, let's say a very efficient C++ program. Our Node.js code will then execute that C++ program in a new process, not blocking its other activities, and when complete process its output.
Two functions that we will use to execute shell commands are <code>exec()</code> and <code>spawn()</code>.
<h2 id="theexecfunction">The <code>exec()</code> Function</h2>
The <code>exec()</code> function creates a new shell and executes a given command. The output from the execution is buffered, which means kept in memory, and is available for use in a callback.
Let's use the <code>exec()</code> function to list all folders and files in our current directory. In a new Node.js file called <code>lsExec.js</code>, write the following code:
<pre><code class="hljs">const { exec } = require(&quot;child_process&quot;);

exec(&quot;ls -la&quot;, (error, stdout, stderr) =&gt; {
 if (error) {
 console.log(`error: ${error.message}`);
 return;
 }
 if (stderr) {
 console.log(`stderr: ${stderr}`);
 return;
 }
 console.log(`stdout: ${stdout}`);
});
</code></pre>
First, we require the <code>child_process</code> module in our program, specifically using the <code>exec()</code> function (via ES6 destructuring). Next, we call the <code>exec()</code> function with two parameters:
<ul>
<li>A string with the shell command we want executed.</li>
<li>A callback function with three parameters: <code>error</code>, <code>stdout</code>, <code>stderr</code>.</li>
</ul>
The shell command we are running is <code>ls -la</code>, which should list all the files and folders in our current directory line by line, including hidden files/folders. The callback function logs whether we got an <code>error</code> while trying to execute the command or output on the shell's <code>stdout</code> or <code>stderr</code> streams.
<blockquote>
Note: The <code>error</code> object is different from <code>stderr</code>. The <code>error</code> object is not null when the <code>child_process</code> module fails to execute a command. This could happen if you try to execute another Node.js script in <code>exec()</code> but the file could not be found, for example. On the other hand, if the command successfully runs and writes a message to the standard error stream, then the <code>stderr</code> object would not be null.
</blockquote>
If you run that Node.js file, you should see output similar to:
<pre><code class="hljs">$ node lsExec.js
stdout: total 0
drwxr-xr-x@ 9 arpan arpan 0 Dec 7 00:14 .
drwxr-xr-x@ 4 arpan arpan 0 Dec 7 22:09 ..
-rw-r--r--@ 1 arpan arpan 0 Dec 7 15:10 lsExec.js

child process exited with code 0
</code></pre>
Now that we've understood how to run commands with <code>exec()</code>, let's learn another way to execute commands with <code>spawn()</code>.
<h2 id="thespawnfunction">The <code>spawn()</code> Function</h2>
The <code>spawn()</code> function executes a command in a new process. This function uses a <a target="_blank" href="/introduction-to-node-js-streams">Stream API</a>, so its output of the command is made available via listeners.
Similar to before, we will use the <code>spawn()</code> function to list all folders and files in our current directory. Let's create a new Node.js file, <code>lsSpawn.js</code>, and enter the following:
<pre><code class="hljs">const { spawn } = require(&quot;child_process&quot;);

const ls = spawn(&quot;ls&quot;, [&quot;-la&quot;]);

ls.stdout.on(&quot;data&quot;, data =&gt; {
 console.log(`stdout: ${data}`);
});

ls.stderr.on(&quot;data&quot;, data =&gt; {
 console.log(`stderr: ${data}`);
});

ls.on(&#x27;error&#x27;, (error) =&gt; {
 console.log(`error: ${error.message}`);
});

ls.on(&quot;close&quot;, code =&gt; {
 console.log(`child process exited with code ${code}`);
});
</code></pre>
We begin by requiring the <code>spawn()</code> function from the <code>child_process</code> module. Then, we create a new process that executes the <code>ls</code> command, passing <code>-la</code> as an argument. Note how the arguments are held in an array and not included in the command string.
We then set up our listeners. The <code>stdout</code> object of <code>ls</code>, fires a <code>data</code> event when the command writes to that stream. Similarly, the <code>stderr</code> also fires a <code>data</code> event when the command writes to that stream.
Errors are caught by listening for them directly on the object that stores the reference for the command. You will only get an error if <code>child_process</code> fails to run the command.
The <code>close</code> event occurs when the command has finished.
If we run this Node.js file, we should get output like before with <code>exec()</code>:
<pre><code class="hljs">$ node lsSpawn.js
stdout: total 0
drwxr-xr-x@ 9 arpan arpan 0 Dec 7 00:14 .
drwxr-xr-x@ 4 arpan arpan 0 Dec 7 22:09 ..
-rw-r--r--@ 1 arpan arpan 0 Dec 7 15:10 lsExec.js
-rw-r--r--@ 1 arpan arpan 0 Dec 7 15:40 lsSpawn.js

child process exited with code 0
</code></pre>
<h2 id="whentouseexecandspawn">When to use <code>exec()</code> and <code>spawn()</code>?</h2>
The key difference between <code>exec()</code> and <code>spawn()</code> is how they return the data. As <code>exec()</code> stores all the output in a buffer, it is more memory intensive than <code>spawn()</code>, which streams the output as it comes.
Generally, if you are not expecting large amounts of data to be returned, you can use <code>exec()</code> for simplicity. Good examples of use-cases are creating a folder or getting the status of a file. However, if you are expecting a large amount of output from your command, then you should use <code>spawn()</code>. A good example would be using commands to manipulate binary data and then loading it into your Node.js program.
<h2 id="conclusion">Conclusion</h2>
Node.js can run shell commands by using the standard <code>child_process</code> module. If we use the <code>exec()</code> function, our command will run and its output will be available to us in a callback. If we use the <code>spawn()</code> module, its output will be available via event listeners.
If our application expects a lot of output from our commands, we should prefer <code>spawn()</code> over <code>exec()</code>. If not, we might opt to use <code>exec()</code> for its simplicity.
Now that you can run tasks external to Node.js, what applications would you build?

Arpan Abhishek

With Node, we can run shell commands and process their I/O using JavaScript, instead of the shell scripting language. This makes the application easier to maintain and develop as we stay in the same environment.

Executing Shell Commands with Node.js

Darinka Zobenica

Dimitrije Stamenic

Design Patterns are battle-hardened, well-adopted approaches to solving common problems. In this article, we'll be exploring the Creational Design Patterns in Python.

Creational Design Patterns in Python

<h3 id="introduction">Introduction</h3>
Design Patterns are reusable models for solving known and common problems in software architecture.
They're best described as templates for dealing with a certain usual situation. An architect might have a template for designing certain kinds of door-frames which he fits into many of his projects, and a software engineer, or software architect, should know templates for solving frequent programming challenges.
A good presentation of a design pattern should include:
<ul>
<li>Name</li>
<li>Motivating problem</li>
<li>Solution</li>
<li>Consequences</li>
</ul>
<h3 id="equivalentproblems">Equivalent Problems</h3>
If you were thinking that that's a pretty <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Fuzzy_logic">fuzzy</a> concept, you'd be right. For instance, we could say that the following &quot;pattern&quot; solves all of your problems:
<ol>
<li>Fetch and prepare the necessary data and other resources</li>
<li>Do the calculations needed and perform the necessary work</li>
<li>Make logs of what you're doing</li>
<li>Release all resources</li>
<li>???</li>
<li>Profit</li>
</ol>
This is an example of thinking too abstract. You can't really call this a pattern because it's not really a good model for solving any problem, despite being technically applicable to any of them (including making dinner).
On the other extreme, you can have solutions that are just too concrete to be called a pattern. For instance, you could wonder whether <a target="_blank" href="/quicksort-in-python/">QuickSort</a> is a pattern for solving the sorting problem.
It certainly is a common programming problem, and QuickSort is a good solution for it. However, it can be applied to any sorting problem with little to no modification.
Once you have it in a library and you can call it, your only real job is to make your object comparable somehow, you don't really have to deal with the essence of it yourself to modify it to fit your particular problem.
Equivalent problems are somewhere between these concepts. These are different problems that are sufficiently similar that you can apply the same model to them, but sufficiently different that this model has to be customized considerably to be applicable in each case.
Patterns that could be applied to these sorts of problems are what we can meaningfully dub design patterns.
<h3 id="whyusedesignpatterns">Why use Design Patterns?</h3>
You're probably familiar with some design patterns already through practice of writing code. A lot of good programmers eventually gravitate towards them even without being explicitly taught or they just pick them up from seniors along the way.
Motivations for making, learning, and utilizing design patterns are manifold. They're a way to give names to complex abstract concepts to enable discussion and teaching.
They make communication within teams faster, because someone can just use the pattern's name instead of whipping out a white board. They enable you to learn from the experiences of people who came before you, rather than having to reinvent the wheel by going through the whole crucible of gradually improving practices yourself (and having to constantly cringe at your old code).
Bad solutions that tend to be commonly invented because they seem logical on the first glance are often called <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Anti-pattern">anti-patterns</a>. In order for something to justly be called an anti-pattern it needs to be commonly reinvented and there needs to be a pattern for the same problem which solves it better.
Despite the obvious utility in practice, design patterns are also useful for learning. They introduce you to many problems that you may not have considered and allow you to think about scenarios that you may not have had hands-on experience with in-depth.
They're a must-learn for all, and they're an exceptionally good learning resource for all aspiring architects and developers who may be at the beginning of their careers and lacking the first-hand experience of grappling with various problems the industry provides.
<h3 id="designpatternsinpython">Design Patterns in Python</h3>
Traditionally, design patterns have been classified into three main categories: <a href="#creationaldesignpatterns">Creational</a>, <a href="#structuraldesignpatterns">Structural</a>, and <a href="#behavioraldesignpatterns">Behavioral</a>. There are other categories, like <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Architectural_pattern">architectural</a> or <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Concurrency_pattern">concurrency</a> patterns, but they're beyond the scope of this article.
There are also Python-specific design patterns that are created specifically around the problems that the structure of the language itself provides or that deal with problems in special ways that are only allowed because of the structure of the language.
Creational Design Patterns deal with creation of classes or objects. They serve to abstract away the specifics of classes so that we'd be less dependent on their exact implementation, or so that we wouldn't have to deal with complex construction whenever we need them, or so we'd ensure some special instantiation properties. They're very useful for lowering levels of dependency and controlling how the user interacts with our classes.
Structural Design Patterns deal with assembling objects and classes into larger structures, while keeping those structures flexible and efficient. They tend to be really useful for improving readability and maintainability of the code, ensure functionalities are properly separated, encapsulated, and that there are effective minimal interfaces between interdependent things.
Behavioral Design Patterns deal with algorithms in general, and assignment of responsibility between interacting objects. For example, they're good practices in cases where you may be tempted to implement a naive solution, like <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Busy_waiting">busy waiting</a>, or load your classes with unnecessary code for one specific purpose that isn't the core of their functionality.
<h3 id="creationaldesignpatterns">Creational Design Patterns</h3>
<ul>
<li><a target="_blank" href="/creational-design-patterns-in-python#factorydesignpattern">Factory</a></li>
<li><a target="_blank" href="/creational-design-patterns-in-python#abstractfactorydesignpattern">Abstract Factory</a></li>
<li><a target="_blank" href="/creational-design-patterns-in-python#builderdesignpattern">Builder</a></li>
<li><a target="_blank" href="/creational-design-patterns-in-python#prototypedesignpattern">Prototype</a></li>
<li><a target="_blank" href="/creational-design-patterns-in-python#singletondesignpattern">Singleton</a></li>
<li><a target="_blank" href="/creational-design-patterns-in-python#objectpooldesignpattern">Object Pool</a></li>
</ul>
<h3 id="structuraldesignpatterns">Structural Design Patterns</h3>
<ul>
<li><a target="_blank" href="/structural-design-patterns-in-python/#adapterdesignpattern">Adapter</a></li>
<li><a target="_blank" href="/structural-design-patterns-in-python/#bridgedesignpattern">Bridge</a></li>
<li><a target="_blank" href="/structural-design-patterns-in-python/#compositedesignpattern">Composite</a></li>
<li><a target="_blank" href="/structural-design-patterns-in-python/#decoratordesignpattern">Decorator</a></li>
<li><a target="_blank" href="/structural-design-patterns-in-python/#facadedesignpattern">Facade</a></li>
<li><a target="_blank" href="/structural-design-patterns-in-python/#flyweightdesignpattern">Flyweight</a></li>
<li><a target="_blank" href="/structural-design-patterns-in-python/#proxy">Proxy</a></li>
</ul>
<h3 id="behavioraldesignpatterns">Behavioral Design Patterns</h3>
Coming soon!
<ul>
<li><a target="_blank" href="#">Chain of Responsibility</a></li>
<li><a target="_blank" href="#">Command</a></li>
<li><a target="_blank" href="#">Iterator</a></li>
<li><a target="_blank" href="#">Mediator</a></li>
<li><a target="_blank" href="#">Memento</a></li>
<li><a target="_blank" href="#">Observer</a></li>
<li><a target="_blank" href="#">State</a></li>
<li><a target="_blank" href="#">Strategy</a></li>
<li><a target="_blank" href="#">Visitor</a></li>
</ul>
<h3 id="pythonspecificdesignpatterns">Python-Specific Design Patterns</h3>
Coming soon!
<ul>
<li><a target="_blank" href="#">Global Object Pattern</a></li>
<li><a target="_blank" href="#">Prebound Method Pattern</a></li>
<li><a target="_blank" href="#">Sentinel Object Pattern</a></li>
</ul>

Design Patterns are a really important topic in Software Engineering. In this article, we'll be discussing what they are, what they aren't as well as dive into some of the most important categories of Design Patterns in Python.

Design Patterns in Python

Janith Kasun

Authentication in many cases allows users to personably perform actions on a website. In this article, we'll be handling authentication in Node with Express.js.