<h2 id="introduction">Introduction</h2>
Modifiers are keywords that let us fine-tune access to our class and its members, their scope, and behavior in certain situations. For example, we can control which classes/objects can access certain members of our class, whether a class can be inherited or not, whether we can override a method later, whether we should override a method later, etc.
Modifier keywords are written before the variable/method/class (return) type and name, e.g. <code>private int myVar</code> or <code>public String toString()</code>.
Modifiers in Java fall into one of two groups - access and non-access:
<ul>
<li>Access: <code>public</code>, <code>private</code>, <code>protected</code></li>
<li>Non-access: <code>static</code>, <code>final</code>, <code>abstract</code>, <code>synchronized</code>, <code>volatile</code>, <code>transient</code>, and <code>native</code></li>
</ul>
Want to learn more about non-access modifiers? Check out our article <a target="_blank" href="/non-access-modifiers-in-java/">Non-Access Modifiers in Java</a>.
<h2 id="accessmodifiers">Access Modifiers</h2>
Access modifiers deal with the visibility of class members. They control whether other classes can see or change certain variables/methods of our class.
These types of modifiers are closely related to an important part of Object Oriented Programming called encapsulation. As a reminder, encapsulation is an idea that links data with the code that manipulates it. By controlling access, you can prevent misuse.
For example, by making sure that certain variables can only be accessed through well-defined methods (the typical get/set combination of methods) we make sure that we won't encounter any unexpected values or deny outside access to certain variables/methods altogether.
As previously mentioned, there are three access modifiers: <code>public</code>, <code>private</code>, and <code>protected</code>. Java also provides default access control (when no modifier is specified), which behaves similarly to <code>protected</code>.
<ul>
<li><code>public</code> - the member can be accessed from anywhere</li>
<li><code>protected</code> - the member is only inaccessible from non-subclasses in a different package</li>
<li>default (package-private) - also known as <code>package</code> access, the member can be accessed by any class within the same package</li>
<li><code>private</code> - the member can only be accessed by other members within the same class</li>
</ul>
This table shows all possible access scenarios for class members:
<table class="table table-striped" style="width:100%">
 <tr align="center">
 <th colspan="2"></th>
 <th>Private</th>
 <th>Default</th>
 <th>Protected</th>
 <th>Public</th>
 </tr>
 <tr align="center">
 <td colspan="2" align="left">Same class</td>
 <td>Yes</td>
 <td>Yes</td>
 <td>Yes</td>
 <td>Yes</td>
 </tr>
 <tr align="center">
 <td colspan="2" align="left">Subclass (same package)</td>
 <td>No</td>
 <td>Yes</td>
 <td>Yes</td>
 <td>Yes</td>
 </tr>
 <tr align="center">
 <td colspan="2" align="left">Non-subclass (same package)</td>
 <td>No</td>
 <td>Yes</td>
 <td>Yes</td>
 <td>Yes</td>
 </tr>
 <tr align="center">
 <td colspan="2" align="left">Subclass (different package)</td>
 <td>No</td>
 <td>No</td>
 <td>Yes</td>
 <td>Yes</td>
 </tr>
 <tr align="center">
 <td colspan="2" align="left">Non-subclass (different package)</td>
 <td>No</td>
 <td>No</td>
 <td>No</td>
 <td>Yes</td>
 </tr>
</table>
This table applies only to class members, not classes in general. A non-nested class can only be <code>public</code> or without a modifier. The behavior is logical, when a class is declared without a modifier it can only be accessed by code within the same package, and when it is declared <code>public</code> it can be used in a different package as well.
Note: A <code>public</code> class must be the only (non-nested) class in the file, and the file must have the same name as the class.
For example, let's say we have two packages, creatively named <code>packageOne</code> and <code>packageTwo</code>.
<pre><code class="hljs">package packageOne;

public class MyPublicClass {
 String noModifierText = &quot;No Modifier&quot;;
 private String privateText = &quot;Private Text&quot;;
 protected String protectedText = &quot;Protected Text&quot;;
 public String publicText = &quot;Public Text&quot;;

 public MyPublicClass() {
 // We can access all members of a class from within that class
 System.out.println(&quot;MyPublicClass constructor:&quot;)
 System.out.println(noModifierText);
 System.out.println(privateText);
 System.out.println(protectedText);
 System.out.println(publicText);
 }
}
</code></pre>
Note that the above code is in a file called &quot;MyPublicClass.java&quot;. The name must match the class since we'll make the class public so we can access it from a different package. The same applies to the other classes below.
<pre><code class="hljs">package packageOne;

class SamePackageExtends extends MyPublicClass {
 public SamePackageExtends() {
 System.out.println(&quot;SamePackageExtends constructor:&quot;)
 System.out.println(noModifierText);
 // Trying to access the private member privateText will fail, since private members
 // can only be accessed by members of the same class, even though this class extends it.
 // System.out.println(privateText);
 System.out.println(protectedText);
 System.out.println(publicText);
 }
}
</code></pre>
<pre><code class="hljs">package packageOne;

class SamePackageDoesntExtend {
 // Has the same access as SamePackageExtends
 public SamePackageDoesntExtend() {
 MyPublicClass myPublicClass = new MyPublicClass();

 System.out.println(&quot;SamePackageDoesntExtend constructor:&quot;)
 System.out.println(myPublicClass.noModifierText);
 // System.out.println(myPublicClass.privateText);
 System.out.println(myPublicClass.protectedText);
 System.out.println(myPublicClass.publicText);
 }
}
</code></pre>
<pre><code class="hljs">package packageTwo;

class DifferentPackageExtends extends packageOne.MyPublicClass {
 public DifferentPackageExtends() {
 System.out.println(&quot;DifferentPackageExtends constructor:&quot;)
 // System.out.println(noModifierText); // Same class or same package only
 // System.out.println(privateText); // Same class only
 System.out.println(protectedText);
 System.out.println(publicText);
 }
}
</code></pre>
<pre><code class="hljs">package packageTwo;

class DifferentPackageDoesntExtend {
 public DifferentPackageDoesntExtend() {
 packageOne.MyPublicClass myPublicClass = new packageOne.MyPublicClass();

 System.out.println(&quot;DifferentPackageDoesntExtend constructor:&quot;)
 // System.out.println(myPublicClass.noModifierText);
 // System.out.println(myPublicClass.privateText);
 // System.out.println(myPublicClass.protectedText); // Same package only
 System.out.println(myPublicClass.publicText);
 }
}
</code></pre>
Tip: It's common practice to encapsulate a class. This means that we declare member variables as <code>private</code> and declare <code>public</code> methods that manipulate them. For example, we want to let someone change <code>int ID</code> field but we also want to make sure that <code>int ID</code> is strictly a positive integer. Though the public method, we can first run a check and manipulate the field if the given value passes our check. This is a construct called a <code>set()</code> method, and it's usually accompanied by a <code>get()</code> method (since we can't read private members outside of our class) or when we want to control how and when the value of a variable can be read.
<pre><code class="hljs">class GetSetExample {
 ...
 private int ID = 0; // Default value
 public setID(int n) {
 if (n &gt; 0) {
 ID = n;
 }
 else ID = 0;
 }
 public int getID() {
 // Potential read conditions that need to be met

 return ID;
 }
 ...
}
</code></pre>
One other thing to note is that <code>protected</code> is the least used of all of the access modifiers. It can easily be bypassed if we want to. Even in a different package we can simply inherit the class whose <code>protected</code> members we want to access, and then access them via that inherited class.
With that in mind, <code>protected</code> is most often used as a guideline that says &quot;This member is not meant to be accessed by non-subclasses in a different package&quot;, so even though we can easily bypass <code>protected</code> access control, it's not advisable, since it was most likely put there for a reason.
<h2 id="conclusion">Conclusion</h2>
Modifiers are keywords that let us fine-tune access to our class and its members, their scope and behavior in certain situations. They provide fundamental traits for our classes and their members. Every developer should be thoroughly be acquainted with them to make the best use of them.

Olivera Popović

Access Modifiers in Java

Guest Contributor

HashMap and TreeMap in Java: Differences and Similarities

In this article, we'll examine how to append content to an existing file using Python.
Let's say we have a file called <code>helloworld.txt</code> containing the text &quot;Hello world!&quot; and it is sitting in our current working directory on a Unix file system:
<pre><code class="hljs">$ cat ./helloworld.txt
Hello world!
</code></pre>
Now assume we want to append the additional text &quot;It's good to have been born!&quot; to the end of this file from a Python program.
The first step is to obtain a reference to the file from our program. This can be done with the built-in <code>open</code> method, using the file path/name as the first argument and the mode as the second argument, as follows:
<pre><code class="hljs">f = open(&quot;./helloworld.txt&quot;, &quot;a&quot;)
</code></pre>
The variable <code>f</code> now holds a reference to a file object that we can use to write to the end of the file. If the file didn't already exist, it will be created. Note that the second argument &quot;a&quot; specified the mode to open the file with, in this case &quot;Append&quot; mode. This sets the writing position to the end of the file.
If we had used the &quot;w&quot; (Write mode), then anything we write to the file will start at the very beginning and overwrite the existing content.
Now we can write content to the file like this:
<pre><code class="hljs">f.write(&quot;\nIt&#x27;s good to have been born!&quot;)

f.close()
</code></pre>
Remember to call the <code>close</code> method after writing to files so that it doesn't remain locked after the program exits and to ensure that any buffered content in memory gets written to the file.
Here is what the file looks like after we append to it:
<pre><code class="hljs">$ cat ./helloworld.txt
Hello world!
It&#x27;s good to have been born!
</code></pre>
One final note is that if we add a &quot;+&quot; to the mode argument of the <code>open</code> method, we can open the file for both appending and reading. This will enable both reading and writing to the file. Without the &quot;+&quot; an <code>IOError</code> exception will occur if we try to read from the file. By default both reading and writing will occur at the end of the file, but this can be changed at any time using the <code>seek</code> method.
Here are the commands to achieve this (note that we use the <code>flush</code> method to ensure the new content is written to the file before we try to read it back):
<pre><code class="hljs">f = open(&quot;./helloworld.txt&quot;, &quot;a+&quot;)
f.write(&quot;I am grateful.&quot;)
f.flush() 
f.seek(0)
content = f.read()
print content
f.close()
</code></pre>
And here is what the final file looks like:
<pre><code class="hljs">$ cat ./helloworld.txt
Hello world!
It&#x27;s good to have been born!
I am grateful.
</code></pre>
<h2 id="abouttheauthor">About the Author</h2>
This article was written by Jacob Stopak, a software consultant and developer with passion for helping others improve their lives through code. Jacob is the creator of <a rel="nofollow" target="_blank" href="https://initialcommit.com">Initial Commit</a> - a site dedicated to helping curious developers learn how their favorite programs are coded. Its featured project helps people <a rel="nofollow" target="_blank" href="https://initialcommit.com/blog/Learn-Git-Code-Definitive-Guide">learn Git</a> at the code level.
In this article, we'll examine how to append content to an existing file using Python.
Let's say we have a file called <code>helloworld.txt</code> containing the text &quot;Hello world!&quot; and it is sitting in our current working directory on a Unix file system:
<pre><code class="hljs">$ cat ./helloworld.txt
Hello world!
</code></pre>
Now assume we want to append the additional text &quot;It's good to have been born!&quot; to the end of this file from a Python program.
The first step is to obtain a reference to the file from our program. This can be done with the built-in <code>open</code> method, using the file path/name as the first argument and the mode as the second argument, as follows:
<pre><code class="hljs">f = open(&quot;./helloworld.txt&quot;, &quot;a&quot;)
</code></pre>
The variable <code>f</code> now holds a reference to a file object that we can use to write to the end of the file. If the file didn't already exist, it will be created. Note that the second argument &quot;a&quot; specified the mode to open the file with, in this case &quot;Append&quot; mode. This sets the writing position to the end of the file.
If we had used the &quot;w&quot; (Write mode), then anything we write to the file will start at the very beginning and overwrite the existing content.
Now we can write content to the file like this:
<pre><code class="hljs">f.write(&quot;\nIt&#x27;s good to have been born!&quot;)

f.close()
</code></pre>
Remember to call the <code>close</code> method after writing to files so that it doesn't remain locked after the program exits and to ensure that any buffered content in memory gets written to the file.
Here is what the file looks like after we append to it:
<pre><code class="hljs">$ cat ./helloworld.txt
Hello world!
It&#x27;s good to have been born!
</code></pre>
One final note is that if we add a &quot;+&quot; to the mode argument of the <code>open</code> method, we can open the file for both appending and reading. This will enable both reading and writing to the file. Without the &quot;+&quot; an <code>IOError</code> exception will occur if we try to read from the file. By default both reading and writing will occur at the end of the file, but this can be changed at any time using the <code>seek</code> method.
Here are the commands to achieve this (note that we use the <code>flush</code> method to ensure the new content is written to the file before we try to read it back):
<pre><code class="hljs">f = open(&quot;./helloworld.txt&quot;, &quot;a+&quot;)
f.write(&quot;I am grateful.&quot;)
f.flush() 
f.seek(0)
content = f.read()
print content
f.close()
</code></pre>
And here is what the final file looks like:
<pre><code class="hljs">$ cat ./helloworld.txt
Hello world!
It&#x27;s good to have been born!
I am grateful.
</code></pre>
<h2 id="abouttheauthor">About the Author</h2>
This article was written by Jacob Stopak, a software consultant and developer with passion for helping others improve their lives through code. Jacob is the creator of <a rel="nofollow" target="_blank" href="https://initialcommit.com">Initial Commit</a> - a site dedicated to helping curious developers learn how their favorite programs are coded. Its featured project helps people <a rel="nofollow" target="_blank" href="https://initialcommit.com/blog/Learn-Git-Code-Definitive-Guide">learn Git</a> at the code level.

Jacob Stopak

Python: Append Contents to a File

Overview of Async IO in Python 3.7

<h2 id="introduction">Introduction</h2>
In this tutorial, we're going to learn how to use <a rel="nofollow" target="_blank" href="http://pyopengl.sourceforge.net">PyOpenGL</a> library in Python. OpenGL is a graphics library which is supported by multiple platforms including Windows, Linux, and MacOS, and is available for use in multiple other languages as well; however, the scope of this post will be limited to its usage in the Python programming language.
OpenGL, as compared to other similar graphics libraries, is fairly simple. We'll start with setting it up on our system, followed by writing a simple example demonstrating the usage of the library.
<h2 id="installation">Installation</h2>
The easiest way to install OpenGL using Python is through the <a rel="nofollow" target="_blank" href="https://pypi.org/project/pip/">pip</a> package manager. If you have pip installed in your system, run the following command to download and install OpenGL:
<pre><code class="hljs">$ pip install PyOpenGL PyOpenGL_accelerate
</code></pre>
I'd recommend copying the above command to help avoid typos.
Once this command finishes execution, if the installation is successful, you should get the following output at the end:
<pre><code class="hljs">Successfully installed PyOpenGL-3.1.0 PyOpenGL-accelerate-3.1.0
</code></pre>
If this doesn't work, you can also download it manually. For that, <a rel="nofollow" target="_blank" href="http://pyopengl.sourceforge.net">this link</a>, scroll down to the 'downloading and installation' heading, and download all the files over there. After that, navigate to the folder where you downloaded those files, and run the following command in the terminal or command prompt:
<pre><code class="hljs">$ python setup.py
</code></pre>
It is pertinent to mention that you require Visual C++ 14.0 build tools installed on your system in order to work with OpenGL libraries in Python.
Now that we have successfully installed OpenGL on our system, let's get our hands dirty with it.
<h2 id="codingexercise">Coding Exercise</h2>
The first thing we need to do to use OpenGL in our code is to import it. To do that, run the following command:
<pre><code class="hljs">import OpenGL
</code></pre>
Before we proceed, there are a few other libraries that you need to import whenever you intend to use this library in your program. Below is the code for those imports:
<pre><code class="hljs">import OpenGL.GL
import OpenGL.GLUT
import OpenGL.GLU
print(&quot;Imports successful!&quot;) # If you see this printed to the console then installation was successful
</code></pre>
Now that we are done with the necessary imports, let's first create a window in which our graphics will be shown. The code for that is given below, along with its explanation in the comments:
<pre><code class="hljs">def showScreen():
 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) # Remove everything from screen (i.e. displays all white)

glutInit() # Initialize a glut instance which will allow us to customize our window
glutInitDisplayMode(GLUT_RGBA) # Set the display mode to be colored
glutInitWindowSize(500, 500) # Set the width and height of your window
glutInitWindowPosition(0, 0) # Set the position at which this windows should appear
wind = glutCreateWindow(&quot;OpenGL Coding Practice&quot;) # Give your window a title
glutDisplayFunc(showScreen) # Tell OpenGL to call the showScreen method continuously
glutIdleFunc(showScreen) # Draw any graphics or shapes in the showScreen function at all times
glutMainLoop() # Keeps the window created above displaying/running in a loop
</code></pre>
Copy the imports above, as well as this code in a single python (.py) file, and execute it. You should see a white square dimension screen pop up. Now, if we wish to draw any shapes or make any other kind of graphics, we need to do that in our &quot;showScreen&quot; function.
Let's now try to make a square using OpenGL, but before we do we need to understand the coordinate system that OpenGL follows.
The (0,0) point is the bottom left of your window, if you go up from there, you're moving along the y-axis, and if you go right from there, you're moving along the x-axis. So, the top left point of your window would be (0, 500), top right would be (500, 500), bottom right would be (500, 0).
Note: We're talking about the window we created above, which had a dimension of 500 x 500 in our example, and not your computer's full screen.
Now that we've got that out of the way, let's code a square. The explanation to the code can be found in the comments.
<pre><code class="hljs">from OpenGL.GL import *
from OpenGL.GLUT import *
from OpenGL.GLU import *

w, h = 500,500

# ---Section 1---
def square():
 # We have to declare the points in this sequence: bottom left, bottom right, top right, top left
 glBegin(GL_QUADS) # Begin the sketch
 glVertex2f(100, 100) # Coordinates for the bottom left point
 glVertex2f(200, 100) # Coordinates for the bottom right point
 glVertex2f(200, 200) # Coordinates for the top right point
 glVertex2f(100, 200) # Coordinates for the top left point
 glEnd() # Mark the end of drawing

# This alone isn&#x27;t enough to draw our square

# ---Section 2---

def showScreen():
 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) # Remove everything from screen (i.e. displays all white)
 glLoadIdentity() # Reset all graphic/shape&#x27;s position
 square() # Draw a square using our function
 glutSwapBuffers()

#---Section 3---

glutInit()
glutInitDisplayMode(GLUT_RGBA) # Set the display mode to be colored
glutInitWindowSize(500, 500) # Set the w and h of your window
glutInitWindowPosition(0, 0) # Set the position at which this windows should appear
wind = glutCreateWindow(&quot;OpenGL Coding Practice&quot;) # Set a window title
glutDisplayFunc(showScreen)
glutIdleFunc(showScreen) # Keeps the window open
glutMainLoop() # Keeps the above created window displaying/running in a loop
</code></pre>
Running the code above would draw a square, but that square would not be visible since it's color would be the same as the color of our window, so we need to assign it a different color as well, for that we will make some changes in &quot;Section 2&quot; of the code above i.e. the <code>showScreen</code> function. Add the following line below the <code>glLoadIdentity</code> statement and above the <code>square()</code> statement:
<pre><code class="hljs">glColor3f(1.0, 0.0, 3.0) # Set the color to pink
</code></pre>
However, our code is still not complete. What it currently does is draw the square once, and then clear the screen again. We don't want that. Actually, we won't even be able to spot the moment when it actually draws the square because it would appear and disappear in a split second. Let's write another function to avoid this.
<pre><code class="hljs"># Add this function before Section 2 of the code above i.e. the showScreen function
def iterate():
 glViewport(0, 0, 500,500)
 glMatrixMode(GL_PROJECTION)
 glLoadIdentity()
 glOrtho(0.0, 500, 0.0, 500, 0.0, 1.0)
 glMatrixMode (GL_MODELVIEW)
 glLoadIdentity()
</code></pre>
Call this iterate function in &quot;Section 2&quot; of the code above. Add it below <code>glLoadIdentity</code> and above the <code>glColor3d</code> statement in the <code>showScreen</code> function.
Let's now compile all this into a single code file so that there are no ambiguities:
<pre><code class="hljs">from OpenGL.GL import *
from OpenGL.GLUT import *
from OpenGL.GLU import *

w,h= 500,500
def square():
 glBegin(GL_QUADS)
 glVertex2f(100, 100)
 glVertex2f(200, 100)
 glVertex2f(200, 200)
 glVertex2f(100, 200)
 glEnd()

def iterate():
 glViewport(0, 0, 500, 500)
 glMatrixMode(GL_PROJECTION)
 glLoadIdentity()
 glOrtho(0.0, 500, 0.0, 500, 0.0, 1.0)
 glMatrixMode (GL_MODELVIEW)
 glLoadIdentity()

def showScreen():
 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
 glLoadIdentity()
 iterate()
 glColor3f(1.0, 0.0, 3.0)
 square()
 glutSwapBuffers()

glutInit()
glutInitDisplayMode(GLUT_RGBA)
glutInitWindowSize(500, 500)
glutInitWindowPosition(0, 0)
wind = glutCreateWindow(&quot;OpenGL Coding Practice&quot;)
glutDisplayFunc(showScreen)
glutIdleFunc(showScreen)
glutMainLoop()
</code></pre>
When you run this, a window should appear with a pink colored square box in it.
Output:
<img class="img-responsive" src="https://s3.amazonaws.com/stackabuse/media/brief-introduction-opengl-python-pyopengl-1.png">
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we learned about OpenGL, how to download and install it, followed by using it as a short example program. In this example we also practiced making a basic shape using OpenGL, which gave us an insight into some complex function calls that need to be made whenever we need to draw something using this library. To conclude, OpenGL is very resourceful and gets more and more complex as we dive deeper into it.

Muhammad Junaid Khalid

Brief Introduction to OpenGL in Python with PyOpenGL

Usman Malik

Python for NLP: Working with the Gensim Library (Part 2)

Lucas Otero

Building GraphQL APIs with Vue.js and Apollo Client

<h2 id="introduction">Introduction</h2>
Deploying an application requires developers to put thought and consideration into how it is configured. Many apps are deployed in a development environment before being deployed to the production environment. We need to ensure each environment is configured correctly, it could be disastrous if our production application was using our development database, for example.
Environment variables allow us to manage the configuration of our applications separate from our codebase. Separating configurations make it easier for our application to be deployed in different environments.
Large applications tend to have many environment variables. To better manage them we can use the <a rel="nofollow" target="_blank" href="https://www.npmjs.com/package/dotenv">dotenv</a> library, which allows us to load environment variables from a file.
<h2 id="whatareenvironmentvariables">What are Environment Variables?</h2>
From programming we know that variables are stored values that can be changed. They're mutable and can vary - hence the name variables.
Environment variables are variables external to our application which reside in the OS or the container of the app is running in. An environment variable is simply a name mapped to a value.
By convention, the name is capitalized e.g. <code>SENDER_EMAIL_ADDRESS=me@thisemail.com</code>. The values are strings.
If you open the terminal or command line application in Linux, Mac OS, or Windows and enter <code>set</code>, you will see a list of all environment variables for your user.
<h2 id="whyuseenvironmentvariables">Why use Environment Variables?</h2>
Environment variables are excellent for decoupling application configurations. Typically, our applications require many variables to be set in order for them to work. By relying on external configurations, your app can easily be deployed on different environments. These changes are independent of code changes, so they do not require your application to be rebuilt to change.
Data which changes depending on the environment your app is running on should be set as environment variables. Some common examples are:
<ul>
<li>HTTP Port and Address</li>
<li>Database, cache, and other storage connection information</li>
<li>Location of static files/folders</li>
<li>Endpoints of external services
<ul>
<li>For example, in a development environment your app will point to a test API URL, whereas in a production environment your app will point to the live API URL.</li>
</ul>
</li>
</ul>
Sensitive data like API keys should not be in the source code, or known to persons who do not need access to those external services.
<h2 id="environmentvariablesinnodejs">Environment Variables in Node.js</h2>
Consider a hello world <a rel="nofollow" target="_blank" href="https://nodejs.org/">Node.js</a> application with environment variables for the host and port the app runs on.
Create a new file called <code>hello.js</code> in a workspace of your choosing and add the following:
<pre><code class="hljs">const http = require(&#x27;http&#x27;);

// Read the host address and the port from the environment
const hostname = process.env.HOST;
const port = process.env.PORT;

// Return JSON regardless of HTTP method or route our web app is reached by
const server = http.createServer((req, res) =&gt; {
 res.statusCode = 200;
 res.setHeader(&#x27;Content-Type&#x27;, &#x27;application/json&#x27;);
 res.end(`{&quot;message&quot;: &quot;Hello World&quot;}`);
});

// Start a TCP server listening for connections on the given port and host
server.listen(port, hostname, () =&gt; {
 console.log(`Server running at http://${hostname}:${port}/`);
});
</code></pre>
Node.js provides a global variable <code>process.env</code>, an object that contains all environment variables available to the user running the application. It is expecting the hostname and the port that the app will run on to be defined by the environment.
You can run this application by entering this command in the terminal, <code>HOST=localhost PORT=3000 node hello.js</code>, granted you have Node.js installed. You will notice the following message on your console:
<pre><code class="hljs">Server running at http://localhost:3000/
</code></pre>
Creating and reading environment variables is that easy. Let's say we are writing a micro-service which communicates with a <a rel="nofollow" target="_blank" href="https://www.mysql.com/">MySQL</a> and <a rel="nofollow" target="_blank" href="https://redis.io/">Redis</a> instance, we would like to have the connection details available in our environment variables as well.
We might end up with a command like this:
<pre><code class="hljs">$ DB_HOST=localhost DB_PORT=3306 DB_USER=test DB_PASSWORD=verySecret123!$ DB_MAX_CONNECTIONS=15 CACHE_ADDR=localhost CACHE_PORT= 6379 HOST=localhost PORT=3000 node hello.js
</code></pre>
Developing with multiple environment variables quickly becomes unwieldy. It would be better if the environment variables we had to configure were stored in one central place to the application, like a file.
<h2 id="thedotenvlibrary">The <code>dotenv</code> Library</h2>
This library does one simple task: loads environment variables from a <code>.env</code> file into the <code>process.env</code> variable in Node.js. Let's use <code>dotenv</code> for the previous example.
First, we need to install it via <code>npm</code>:
<pre><code class="hljs">$ npm init # Optional, creates a local package.json that prevents global installs
$ npm install dotenv --save
</code></pre>
And then we make one minimal code change, add this line to the top of <code>hello.js</code>:
<pre><code class="hljs">require(&#x27;dotenv&#x27;).config()
</code></pre>
Now in the same directory of your app, create a new file called <code>.env</code> and add the following:
<pre><code class="hljs">HOST=localhost
PORT=3000
</code></pre>
Your environment variables are declared just as if you were entering them in the shell before running the node command. Instead of separating each variable assignment by a space, we separate them by a newline. Now in your shell, if you enter <code>node hello.js</code>, the app will be running on port <code>3000</code> on your <code>localhost</code>!
Even if <code>dotenv</code> is used in the application, it is completely optional. If no <code>.env</code> file is found, the library fails silently. You can continue to use environment variables defined outside the file.
Note: There are also many variations of <code>dotenv</code> across other programming languages and frameworks. A very popular guideline for building modern web applications is <a rel="nofollow" target="_blank" href="https://12factor.net/">The Twelve-Factor App</a>. The document was created by many developers who created Software-as-a-Service applications. One of the 12 considerations of a modern, scalable app is configuration, specifically the use of environment variables to store configuration. The popularity of this methodology has helped fuel the creation and popularity of <code>dotenv</code> and similar modules.
<h3 id="productionusage">Production Usage</h3>
Storing your environment variables in a file comes with one golden rule: never commit it to the source code repository. You do not want outsiders gaining access to secrets, like API keys. If you are using <code>dotenv</code> to help manage your environment variables, be sure to include the <code>.env</code> file in your <code>.gitignore</code> or the appropriate blacklist for your version control tool.
If you cannot commit the <code>.env</code> file, then there needs to be some way for a developer to know what environment variables are required to run the software. It is common for developers to list the environment variables necessary to run the program in a <code>README</code> or similar internal documentation.
Some developers create and maintain a <code>.sample-env</code> file in the source code repository. This sample file would list all the environment variables used by the app, for example:
<pre><code class="hljs">HOST=
PORT=
</code></pre>
A developer would then clone the repository, copy the <code>.sample-env</code> file into a new <code>.env</code> file and fill in the values.
If your app is running on a physical machine or a virtual machine (for example, <a rel="nofollow" target="_blank" href="https://www.digitalocean.com/products/droplets/">Digital Ocean droplets</a>, <a rel="nofollow" target="_blank" href="https://aws.amazon.com/ec2/">Amazon EC2</a> and <a rel="nofollow" target="_blank" href="https://azure.microsoft.com/en-us/services/virtual-machines/">Azure Virtual Machines</a>), then you can create a <code>.env</code> while logged into the server and it would run just as it is done on your local machine.
If your app is running on a docker container or a Platform-as-a-Service provider like <a rel="nofollow" target="_blank" href="https://www.heroku.com/">Heroku</a> or <a rel="nofollow" target="_blank" href="https://www.openshift.com/">OpenShift</a>, then you will be able to configure environment variables without having to use the <code>.env</code> file.
Remember, it fails silently so it would not affect the running of the app if the file is missing.
<h2 id="conclusion">Conclusion</h2>
Environment variables exist outside our application's code, they are available where our application is running. They can be used to decouple our application's configuration from its code, which allows our apps to be easily deployed across different environments.
With Node.js apps, environment variables are available through the <code>process.env</code> global variable. We can set the environment variables before we run the <code>node</code> command, or we can use the <code>dotenv</code> library which allows us to define our environment variables in a <code>.env</code> file.
The <code>.env</code> file should never be in the source code repository.

Marcus Sanatan

Managing Environment Variables in Node.js with dotenv

This article is the second in a series on working with PDFs in Python:
<ul>
<li><a target="_blank" href="/working-with-pdfs-in-python-adding-images-and-watermarks/">Reading and Splitting Pages</a></li>
<li>Adding Images and Watermarks (you are here)</li>
<li><a target="_blank" href="/working-with-pdfs-in-python-inserting-deleting-and-reordering-pages/">Inserting, Deleting, and Reordering Pages</a></li>
</ul>
<h2 id="introduction">Introduction</h2>
Today, a world without the Portable Document Format (PDF) seems to be unthinkable. It has become one of the most commonly used data formats ever. Up to PDF version 1.4, displaying a PDF document in an according PDF viewer works fine. Unfortunately, the features from the newer PDF revisions, such as forms, are tricky to implement, and still require further work to be fully functional in the tools. Using various Python libraries you can create your own application in a comparable easy way.
This article is part two of a little series on PDFs with Python. In <a target="_blank" href="https://stackabuse.com/working-with-pdfs-in-python-reading-and-splitting-pages/">part one</a> we already gave you an introduction into reading PDF documents using Python, and started with a summary of the various Python libraries. An introduction followed that showed how to manipulate existing PDFs, and how to read and extract the content - both the text and images. Furthermore, we showed you how to split documents into its single pages.
In this article you will learn how to add images to your PDF in the form of watermarks, stamps, and barcodes. For example this is quite helpful in order to stamp or mark documents that are intended to be read by a specific audience, only, or have a draft quality, or to simply add a barcode for identification purposes.
<h2 id="addingawatermarkviacommandlinewithpdftk">Adding a Watermark via Command Line with <code>pdftk</code></h2>
In order to add a watermark to an existing PDF on a Unix/Linux command-line we can use <a rel="nofollow" target="_blank" href="https://www.pdflabs.com/tools/pdftk-the-pdf-toolkit/">pdftk</a>. The name abbreviates &quot;PDF Toolkit&quot;, and describes itself as &quot;a simple tool for doing everyday things with PDF documents&quot;. <code>pdftk</code> has been ported to Java, and made available as an according <a rel="nofollow" target="_blank" href="https://packages.debian.org/buster/pdftk-java">package</a> for Debian GNU/Linux.
In order for this to work you need to have a background image available that comes with the word &quot;DRAFT&quot; on a transparent layer, which you can apply to an existing single-page PDF as follows:
<pre><code class="hljs">$ pdftk input.pdf background background.pdf output output.pdf
</code></pre>
The <code>pdftk</code> tool takes in the PDF file <code>input.pdf</code>, merges it with <code>background.pdf</code>, and outputs the result to the file <code>output.pdf</code>. Figure 1 shows the output of this action.
<img class="img-responsive" alt="Adding a watermark to an existing PDF" src="https://s3.amazonaws.com/stackabuse/media/working-with-pdfs-python-adding-images-watermarks-1.png">
For more complex actions, like stamping a document with different stamps per page, have a look at the description at the PDF Labs <a rel="nofollow" target="_blank" href="https://www.pdflabs.com/docs/how-to-add-headers-footers-watermarks-and-stamps-to-pdf/">project page</a>. We also show the stamping use-case in this article below, although our example uses the library <code>pdfrw</code> instead of <code>pdftk</code>.
<h2 id="addingawatermarkwithpypdf2">Adding a Watermark with PyPDF2</h2>
The <a rel="nofollow" target="_blank" href="https://pypi.org/project/PyPDF2/">PyPDF library</a> provides a method called <code>mergepage()</code> that accepts another PDF to be used as a watermark or stamp.
In the example below we start with reading the first page of the original PDF document and the watermark. To read the file we use the <code>PdfFileReader()</code> class. As a second step we merge the two pages by using the <code>mergepage()</code> method. Finally, we will write the output to the output file. This is done in three steps - creating an object based on the <code>PdfFileWriter()</code> class, adding the merged page to this object using the <code>addPage()</code> method, and writing the new content to the output page using the <code>write()</code> method.
<img class="img-responsive" alt="Adding a watermark to an existing PDF using PyPDF" src="https://s3.amazonaws.com/stackabuse/media/working-with-pdfs-python-adding-images-watermarks-2.png">
<pre><code class="hljs"># !/usr/bin/python
# Adding a watermark to a single-page PDF

import PyPDF2

input_file = &quot;example.pdf&quot;
output_file = &quot;example-drafted.pdf&quot;
watermark_file = &quot;draft.pdf&quot;

with open(input_file, &quot;rb&quot;) as filehandle_input:
 # read content of the original file
 pdf = PyPDF2.PdfFileReader(filehandle_input)
 
 with open(watermark_file, &quot;rb&quot;) as filehandle_watermark:
 # read content of the watermark
 watermark = PyPDF2.PdfFileReader(filehandle_watermark)
 
 # get first page of the original PDF
 first_page = pdf.getPage(0)
 
 # get first page of the watermark PDF
 first_page_watermark = watermark.getPage(0)
 
 # merge the two pages
 first_page.mergePage(first_page_watermark)
 
 # create a pdf writer object for the output file
 pdf_writer = PyPDF2.PdfFileWriter()
 
 # add page
 pdf_writer.addPage(first_page)
 
 with open(output_file, &quot;wb&quot;) as filehandle_output:
 # write the watermarked file to the new file
 pdf_writer.write(filehandle_output)
</code></pre>
<h2 id="addinganimagewithpymupdf">Adding an Image with PyMuPDF</h2>
<a rel="nofollow" target="_blank" href="https://github.com/pymupdf/PyMuPDF">PyMuPDF</a> are the Python bindings for MuPDF, which is a lightweight PDF and XPS viewer. In your Python script the module that needs to be imported is named <code>fitz</code>, and this name goes back to the previous name of PyMuPDF.
For this section we are going to show how to add an image by using a barcode as an example since this is a pretty common task. Although the same steps can be applied to adding any kind of image to a PDF.
In order to decorate a PDF document with a barcode we simply add an image as another PDF layer at the desired position. As for image formats, PyMuPDF accepts PNG or JPEG, but not SVG.
The position of the image is defined as a rectangle using the method <code>fitz.Rect()</code> that requires two pairs of coordinates - (x1,y1) and (x2,y2). PyMuPDF interprets the upper-left corner of the page as (0,0).
Having opened the input file and extracted the first page from it, the image containing the barcode is added using the method <code>insertImage()</code>. This method requires two parameters - the position delivered via <code>imageRectangle</code>, and the name of the image file to be inserted. Using the <code>save()</code> method the modified PDF is stored to disk. Figure 2 shows the barcode after it was added to the example PDF.
<img class="img-responsive" alt="Adding a barcode to an existing PDF using PyMuPDF" src="https://s3.amazonaws.com/stackabuse/media/working-with-pdfs-python-adding-images-watermarks-3.png">
<pre><code class="hljs"># !/usr/bin/python

import fitz

input_file = &quot;example.pdf&quot;
output_file = &quot;example-with-barcode.pdf&quot;
barcode_file = &quot;barcode.png&quot;

# define the position (upper-right corner)
image_rectangle = fitz.Rect(450,20,550,120)

# retrieve the first page of the PDF
file_handle = fitz.open(input_file)
first_page = file_handle[0]

# add the image
first_page.insertImage(image_rectangle, fileName=barcode_file)

file_handle.save(output_file)
</code></pre>
<h2 id="addingstampswithpdfrw">Adding Stamps with <code>pdfrw</code></h2>
<a rel="nofollow" target="_blank" href="https://pypi.org/project/pdfrw/">pdfrw</a> is a pure Python-based PDF parser to read and write PDF documents. It faithfully reproduces vector formats without rasterization. For Debian GNU/Linux, the package repository contains releases for both Python 2 and 3.
The following example will demonstrate how to add a barcode or watermark to an existing PDF that contains multiple pages. From the <code>pdfrw</code> package it is sufficient that you import the three classes <code>PdfReader</code>, <code>PdfWriter</code>, and <code>PageMerge</code>. Next, you establish the according reader and writer objects to access the contents of both the PDF, and the watermark. For each page in the original document you continue creating a <code>PageMerge</code> object to which you add the watermark, and which is rendered using the <code>render()</code> method. Finally, you write the modified pages to the output file. Figure 3 shows the modified document next to the code that made the addition possible.
<img class="img-responsive" alt="Adding a watermark to an existing PDF using pdfrw" src="https://s3.amazonaws.com/stackabuse/media/working-with-pdfs-python-adding-images-watermarks-4.png">
<pre><code class="hljs"># !/usr/bin/python
# Adding a watermark to a multi-page PDF

from pdfrw import PdfReader, PdfWriter, PageMerge

input_file = &quot;example.pdf&quot;
output_file = &quot;example-drafted.pdf&quot;
watermark_file = &quot;barcode.pdf&quot;

# define the reader and writer objects
reader_input = PdfReader(input_file)
writer_output = PdfWriter()
watermark_input = PdfReader(watermark_file)
watermark = watermark_input.pages[0]

# go through the pages one after the next
for current_page in range(len(reader_input.pages)):
 merger = PageMerge(reader_input.pages[current_page])
 merger.add(watermark).render()

# write the modified content to disk
writer_output.write(output_file, reader_input)
</code></pre>
<h2 id="conclusion">Conclusion</h2>
Adding images, watermarks, or stamps to a PDF file is quite simple. With a few lines of code this complex-sounding task is solved within minutes. No matter which of the given libraries you choose it works very well.
Part three of this series will exclusively focus on writing/creating PDFs, and will also include both deleting and re-combining single pages into a new document.