<h2 id="introduction">Introduction</h2>
In this article, we'll be diving into the Singleton Design Pattern, implemented in Python.
As time progresses, software gets more tailored to solving specific problems in different domains. While there are many difference in the application-level of our software, some aspects of software design remain largely the same. These aspects might not remain the same for all software out there but will hold true for a lot of scenarios. Therefore, learning and understanding them will be highly beneficial in helping us build resilient programs.
This is the first in a series about Design Patterns in Python and the different patterns that we can utilize to build software.
<h2 id="whatisadesignpattern">What is a Design Pattern?</h2>
A design pattern is a particular approach to solving a recurring problem in software development and is also used to represent good practices. It is not actual code, but it represents a particular way of organizing code to produce the desired solution in a recommended way. This means that we do not have to strictly follow set design patterns for all of our code, but analyze our needs and apply the best-suited design pattern for our needs.
Design patterns arise from a wealth of experience in solving problems in software development and are tried and tested to fit particular scenarios. Another reason to learn about design patterns is that, while a pattern may not work for a particular scenario, it can offer a base off which a solution can be formulated.
However, as much as design patterns can help us out of various situations, it is important to assess the current situation and explore all the options available before jumping directly into a pattern because there may be a better solution out there.
Design patterns are divided into a few broad categories, though mainly Creational patterns, Structural patterns, and Behavioral patterns.
<h2 id="creationalpatterns">Creational Patterns</h2>
There are several aspects of design patterns that set them apart from each other, including the complexity of the design pattern, the application level within a system, and the amount of detail.
Creational patterns include those that define ways to create objects that contribute to increased flexibility and reusability of code throughout the entire application.
Examples of creational patterns include the Singleton pattern, Factory Method, Abstract Factory, Builder and Prototype patterns.
<h2 id="thesingletonpattern">The Singleton Pattern</h2>
<h3 id="definition">Definition</h3>
The singleton pattern is a common creational pattern that is used to define the creation of a single instance of a class while providing a single global access point to that object.
This pattern restricts the number of objects that can be created from a class to one single object that will often-times be shared globally in an application.
<h3 id="motivation">Motivation</h3>
This pattern is commonly implemented in features that require control over access to a shared resource such as a database connection or a file. By ensuring that a class can only be used to create a single instance and providing a single global access point, access to the shared resource can be restricted and integrity can be maintained.
The creation of single instances also helps ensure that some aspects of our programs cannot be overwritten by other classes resulting in unsafe or inefficient code. This also allows us to access the same object in multiple points of our programs without the fear that it may be overwritten at some point in our program.
For instance, database connections are done once in our programs, and the same object is used to perform operations on our database all over the application. If different parts of our application could create their own database connections, integrity issues may arise over time as each part tries to access the database on their own.
<h3 id="implementation">Implementation</h3>
The Singleton pattern requires that the instantiation of a class is restricted to one object only. The control of object creation is achieved by implementing a creation method that saves the created object in a static field.
All calls to this creation method either return the original singleton object or an error signaling the existence of an instantiated object. This prevents the creation of more than one object for our class and maintains the singleton property.
A good analogy of a singleton pattern is that a country can have a single government that controls access and operations within the country. Any attempts to create another government are forbidden.
We can implement this government analogy in a singleton class as follows in Python:
<pre><code class="hljs">class SingletonGovt:
 __instance__ = None

 def __init__(self):
 &quot;&quot;&quot; Constructor.
 &quot;&quot;&quot;
 if SingletonGovt.__instance__ is None:
 SingletonGovt.__instance__ = self
 else:
 raise Exception(&quot;You cannot create another SingletonGovt class&quot;)

 @staticmethod
 def get_instance():
 &quot;&quot;&quot; Static method to fetch the current instance.
 &quot;&quot;&quot;
 if not SingletonGovt.__instance__:
 SingletonGovt()
 return SingletonGovt.__instance__
</code></pre>
In our example, we define the variable that will hold the single object to be instantiated. Our constructor checks if there is an existing class and raises an error.
When fetching the object using the <code>get_instance()</code> method, we check whether an existing instance is available and return it. If not, we create one and return it.
Our <code>SingletonGovt</code> in action:
<pre><code class="hljs">government = SingletonGovt()
print(government)

same_government = SingletonGovt.get_instance()
print(same_government)

another_government = SingletonGovt.get_instance()
print(another_government)

new_government = SingletonGovt()
print(new_government)
</code></pre>
When we run our script, we can see that we have just one <code>SingletonGovt</code> instance stored at a single point in memory. Any attempts to create another government are thwarted by the exception that we raise:
<img src="https://stackabuse.s3.amazonaws.com/media/singleton-design-pattern-in-python-1.png" alt="singleton design pattern in python results">
<h2 id="prosandcons">Pros and Cons</h2>
<h3 id="pros">Pros</h3>
<ul>
<li>The Singleton pattern offers the guarantee that only one instance of our class exists and reduces the risk of unexpected behavior in our program.</li>
<li>Since the creation of the class is controlled by a single class, this offers flexibility since changes only need to be made to one class and object.</li>
</ul>
<h3 id="cons">Cons</h3>
<ul>
<li>A class created using the singleton pattern violates the <a rel="nofollow noopener" target="_blank" href="https://en.wikipedia.org/wiki/Single-responsibility_principle">Single Responsibility Principle</a> since the class may have to handle more than one responsibility at a given time.</li>
<li>Life cycle management can pose problems in other areas such as testing since the singleton class is kept alive during the lifespan of the application and different test cases might require new versions of the class.</li>
</ul>
<h2 id="conclusion">Conclusion</h2>
In this post, we have introduced, discussed and implemented the Singleton Design Pattern.
Just like any other design pattern, it has its pros and cons and while it may be suitable for some situations, it might not apply to all our development needs. It is therefore up to us to analyze the problem at hand and make the decision whether or not the singleton pattern will make our work easier.

Robley Gori

The singleton is a common creational pattern used to define the creation of a single instance and access point to an object. 

In this article, we'll be diving into the Singleton Design Pattern, implemented in Python.

The Singleton Design Pattern in Python

<h2 id="introduction">Introduction</h2>
The Proxy Design Pattern is a design pattern belonging to the set of <a target="_blank" href="/structural-design-patterns-in-java/">structural patterns</a>. Structural patterns are a category of design patterns used to simplify the design of a program on its structural level.
As its name suggests, the proxy pattern means using a proxy for some other entity. In other words, a proxy is used as an intermediary in front of, or wrapped around, an existing object. This can be used, for example, when the actual object is very resource-intensive or when there are certain conditions which need to be checked before using the actual object. A proxy can also be useful if we'd like to limit the access or functionality of an object.
In this article, we'll describe the proxy pattern and show some examples in which it can be used.
<h2 id="theideabehindproxy">The Idea behind Proxy</h2>
Proxy is used to encapsulate functionalities of another object or system. Consider <a rel="nofollow noopener" target="_blank" href="https://en.wikipedia.org/wiki/Java_remote_method_invocation">remote method invocation</a>, for example, which is a way of calling methods on another machine. In Java, this is accomplished via a remote proxy which is essentially an object providing a local representation of another remote object. Calling a method from another machine is then made possible simply by calling a method of the proxy object.
Each proxy is realized in such a way that it offers exactly the same interface to the client as a real object. This means that the client effectively notices no difference while using the proxy object.
There are several type of proxy objects. As can probably be inferred from the previous example, remote proxies are used to access some remote objects or resources. Besides remote proxies, there are also virtual proxies and protection proxies. Let's briefly describe each of them for a better understanding.
<h3 id="remoteproxies">Remote Proxies</h3>
Remote Proxies provide a local representation of another remote object or resource. Remote proxies are responsible not just for representation but also for some maintenance work. Such work could include connecting to a remote machine and maintaining the connection, encoding and decoding characters obtained through networking traffic, parsing, etc.
<h3 id="virtualproxies">Virtual Proxies</h3>
Virtual Proxies wrap expensive objects and loads them on-demand. Sometimes we don't immediately need all functionalities that an object offers, especially if it is memory/time-consuming. Calling objects only when needed might increase performance quite a bit, as we'll see in the example below.
<h3 id="protectionproxies">Protection Proxies</h3>
Protection Proxies are used for checking certain conditions. Some objects or resources might need appropriate authorization for accessing them, so using a proxy is one of the ways in which such conditions can be checked. With protection proxies, we also get the flexibility of having many variations of access control.
For example, if we're trying to provide access to a resource of an operating system, there are usually multiple categories of users. We could have a user who isn't allowed to view or edit the resource, a user who can do with the resource whatever they wish, etc.
Having proxies act as wrappers around such resources is a great way of implementing customized access control.
<h2 id="implementation">Implementation</h2>
<h3 id="virtualproxyexample">Virtual Proxy Example</h3>
One example of a virtual proxy is loading images. Let's imagine that we're building a file manager. Like any other file manager, this one should be able to display images in a folder that a user decides to open.
If we assume there exists a class, <code>ImageViewer</code>, responsible for loading and displaying images - we might implement our file manager by using this class directly. This kind of approach seems logical and straight-forward but it contains a subtle problem.
If we implement the file manager as described above, we're going to be loading images every time they appear in the folder. If the user only wishes to see the name or size of an image, this kind of approach would still load the entire image into memory. Since loading and displaying images are expensive operations, this can cause performance issues.
A better solution would be to display images only when actually needed. In this sense, we can use a proxy to wrap the existing <code>ImageViewer</code> object. This way, the actual image viewer will only get called when the image needs to be rendered. All other operations (such as obtaining the image name, size, date of creation, etc.) don't require the actual image and can therefore be obtained through a much lighter proxy object instead.
Let's first create our main interface:
<pre><code class="hljs">interface ImageViewer {
 public void displayImage();
}
</code></pre>
Next, we'll implement the concrete image viewer. Note that operations occurring in this class are costly:
<pre><code class="hljs">public class ConcreteImageViewer implements ImageViewer {

 private Image image;

 public ConcreteImageViewer(String path) {
 // Costly operation
 this.image = Image.load(path);
 }

 @Override
 public void displayImage() {
 // Costly operation
 image.display();
 }
}
</code></pre>
Now we'll implement our lightweight image viewer proxy. This object will call the concrete image viewer only when needed, i.e. when the client calls the <code>displayImage()</code> method. Until then, no images will be loaded or processed, which will make our program much more efficient.
<pre><code class="hljs">public class ImageViewerProxy implements ImageViewer {

 private String path;
 private ImageViewer viewer;

 public ImageViewerProxy(String path) {
 this.path = path;
 }

 @Override
 public void displayImage() {
 this.viewer = new ConcreteImageViewer(this.path);
 this.viewer.displayImage();
 }
}
</code></pre>
Finally, we'll write the client-side of our program. In the code below, we are creating six different image viewers. First, three of them are the concrete image viewers that automatically load images on creation. The last three images don't load any images into memory on creation.
Only with the last line will the first proxy viewer start loading the image. Compared to the concrete viewers, performance benefits are obvious:
<pre><code class="hljs">public static void main(String[] args) {
 ImageViewer flowers = new ConcreteImageViewer(&quot;./photos/flowers.png&quot;);
 ImageViewer trees = new ConcreteImageViewer(&quot;./photos/trees.png&quot;);
 ImageViewer grass = new ConcreteImageViewer(&quot;./photos/grass.png&quot;);

 ImageViewer sky = new ImageViewerProxy(&quot;./photos/sky.png&quot;);
 ImageViewer sun = new ImageViewerProxy(&quot;./photos/sun.png&quot;);
 ImageViewer clouds = new ImageViewerProxy(&quot;./photos/clouds.png&quot;);

 sky.displayImage();
}
</code></pre>
Another thing we could do is add a <code>null</code>-check in the <code>displayImage()</code> method of the <code>ImageViewerProxy</code>:
<pre><code class="hljs">@Override
public void displayImage() {
 if (this.viewer == null) {
 this.viewer = new ConcreteImageViewer(this.path);
 }
 this.viewer.displayImage();
}
</code></pre>
So, if we call:
<pre><code class="hljs">ImageViewer sky = new ImageViewerProxy(&quot;./photos/sky.png&quot;);

sky.displayImage();
sky.displayImage();
</code></pre>
Only once will the <code>new ConcreteImageViewer</code> call be executed. This will even further decrease the memory footprint of our application.
<blockquote>
Note: This example does not contain fully-compilable Java code. Some method calls, such as <code>Image.load(String path)</code>, are fictional and written in a simplified way mostly for illustration purposes.
</blockquote>
<h3 id="protectionproxyexample">Protection Proxy Example</h3>
In this example, we'll be flying a spaceship. Prior to that, we need to create two things: The <code>Spaceship</code> interface and the <code>Pilot</code> model:
<pre><code class="hljs">interface Spaceship {
 public void fly();
}
</code></pre>
<pre><code class="hljs">public class Pilot {
 private String name;

 // Constructor, Getters, and Setters
}
</code></pre>
Now we're going to implement the <code>Spaceship</code> interface and create an actual spaceship class:
<pre><code class="hljs">public class MillenniumFalcon implements Spaceship {
 @Override
 public void fly() {
 System.out.println(&quot;Welcome, Han. The Millennium Falcon is starting up its engines!&quot;);
 }
}
</code></pre>
The <code>MillenniumFalcon</code> class represents a concrete spaceship which can be used by our <code>Pilot</code>. However, there could be some conditions we might like to check before allowing the pilot to fly the spaceship. For example, perhaps we would like to see if the pilot has the appropriate certificate or if they are old enough to fly. To check these conditions, we can use the proxy design pattern.
In this example, we're going to be checking if the pilot's name is &quot;Han Solo&quot; since he is the rightful owner of the ship. We start by implementing the <code>Spaceship</code> interface as before.
We are going to use <code>Pilot</code> and <code>Spaceship</code> as our class variables since we can obtain all relevant information from them:
<pre><code class="hljs">public class MillenniumFalconProxy implements Spaceship {

 private Pilot pilot;
 private Spaceship falcon;

 public MillenniumFalconProxy(Pilot pilot) {
 this.pilot = pilot;
 this.falcon = new MillenniumFalcon();
 }

 @Override
 public void fly() {
 if (pilot.getName().equals(&quot;Han Solo&quot;)) {
 falcon.fly();
 } else {
 System.out.printf(&quot;Sorry %s, only Han Solo can fly the Falcon!\n&quot;, pilotName);
 }
 }
}
</code></pre>
The client side of the program can then be written as shown below. If &quot;Han Solo&quot; is the pilot, the Falcon will be allowed to fly. Otherwise, it won't be allowed to leave the hangar:
<pre><code class="hljs">public static void main(String[] args) {
 Spaceship falcon1 = new MillenniumFalconProxy(new Pilot(&quot;Han Solo&quot;));
 falcon1.fly();

 Spaceship falcon2 = new MillenniumFalconProxy(new Pilot(&quot;Jabba the Hutt&quot;));
 falcon2.fly();
}
</code></pre>
The output for the above calls will then result in the following:
<pre><code class="hljs">Welcome, Han. The Millennium Falcon is starting up its engines!
Sorry Jabba the Hutt, only Han Solo can fly the Falcon!
</code></pre>
<h2 id="prosandcons">Pros and Cons</h2>
<h3 id="pros">Pros</h3>
<ul>
<li>Security: By using a proxy, certain conditions can be checked while accessing the object and controlled usage of potentially &quot;dangerous&quot; classes and resources is enforced.</li>
<li>Performance: Some objects might be highly demanding in terms of memory and execution time. By using a proxy, we can wrap such objects with costly operations so that they are called only when really needed, or avoid unnecessary instantiation.</li>
</ul>
<h3 id="cons">Cons</h3>
<ul>
<li>
Performance: Yes, performance can also be a disadvantage of the proxy pattern. How, you might ask? Let's say that a proxy object is used to wrap an object existing somewhere across the network. Since this is a proxy, it can hide from the client the fact that remote communication is involved.
This can in turn make the client inclined to write inefficient code because they will not be aware that an expensive network call is being made in the background.
</li>
</ul>
<h2 id="conclusion">Conclusion</h2>
The Proxy Design Pattern is a clever way of using some costly resources or providing certain access rights. It is structurally similar to the <a target="_blank" href="/structural-design-patterns-in-java/#adapter">Adapter</a> and <a target="_blank" href="/structural-design-patterns-in-java/#decorator">Decorator</a> patterns, although with a different purpose.
Proxy can be used in a variety of circumstances since demanding resources are a common occurrence in programming, especially when dealing with databases and networking.
Knowing how to efficiently access those resources while providing appropriate access control is therefore crucial for building scalable and secure applications.

Luka Čupić

The Proxy Pattern is a Structural Pattern which limits the functionality of potentially costly objects through a proxy. In this article, we'll implement two different kinds of Proxies in Java.

The Proxy Design Pattern in Java

Marcus Sanatan

Leodanis Pozo Ramos

Unpacking uses * to assign multiple variables from a single iterable in one assignment statement. This makes your Python code cleaner and quicker to write.

Unpacking in Python: Beyond Parallel Assignment

<h2 id="introduction">Introduction</h2>
In computer science, data can be represented in a lot of different ways, and naturally, every single one of them has its advantages as well as disadvantages in certain fields.
Since computers are unable to process categorical data as these categories have no meaning for them, this information has to be prepared if we want a computer to be able to process it.
This action is called preprocessing. A big part of preprocessing is encoding - representing every single piece of data in a way that a computer can understand (the name literally means &quot;convert to computer code&quot;).
In many branches of computer science, especially machine learning and digital circuit design, One-Hot Encoding is widely used.
In this article, we will explain what one-hot encoding is and implement it in Python using a few popular choices, <a rel="nofollow noopener" target="_blank" href="https://pandas.pydata.org/">Pandas</a> and <a rel="nofollow noopener" target="_blank" href="https://scikit-learn.org/">Scikit-Learn</a>. We'll also compare it's effectiveness to other types of representation in computers, its strong points and weaknesses, as well as its applications.
<h2 id="whatisonehotencoding">What is One-Hot Encoding?</h2>
One-hot Encoding is a type of vector representation in which all of the elements in a vector are 0, except for one, which has 1 as its value, where 1 represents a <code>boolean</code> specifying a category of the element.
There also exists a similar implementation called One-Cold Encoding, where all of the elements in a vector are 1, except for one, which has 0 as its value.
For instance, <code>[0, 0, 0, 1, 0]</code> and <code>[1 ,0, 0, 0, 0]</code> could be some examples of one-hot vectors. A similar technique to this one, also used to represent data, would be <a rel="nofollow noopener" target="_blank" href="https://en.wikipedia.org/wiki/Dummy_variable_(statistics)">dummy variables</a> in statistics.
This is very different from other encoding schemes, which all allow multiple bits to have 1 as its value. Below is a table that compares the representation of numbers from 0 to 7 in binary, Gray code, and one-hot:
<table class="table table-striped">
 <thead>
 <tr>
 <th>Decimal</th>
 <th>Binary</th>
 <th>Gray code</th>
 <th>One-Hot</th>
 </tr>
 </thead>
 <tbody>
 <tr>
 <td>0</td>
 <td>000</td>
 <td>000</td>
 <td>0000000</td>
 </tr>
 <tr>
 <td>1</td>
 <td>001</td>
 <td>001</td>
 <td>0000001</td>
 </tr>
 <tr>
 <td>2</td>
 <td>010</td>
 <td>011</td>
 <td>0000010</td>
 </tr>
 <tr>
 <td>3</td>
 <td>011</td>
 <td>010</td>
 <td>0000100</td>
 </tr>
 <tr>
 <td>4</td>
 <td>100</td>
 <td>110</td>
 <td>0001000</td>
 </tr>
 <tr>
 <td>5</td>
 <td>101</td>
 <td>111</td>
 <td>0010000</td>
 </tr>
 <tr>
 <td>6</td>
 <td>110</td>
 <td>101</td>
 <td>0100000</td>
 </tr>
 <tr>
 <td>7</td>
 <td>111</td>
 <td>100</td>
 <td>1000000</td>
 </tr>
 </tbody>
</table>
Practically, for every one-hot vector, we ask n questions, where n is the number of categories we have:
<blockquote>
Is this the number 1? Is this the number 2? ... Is this the number 7?
</blockquote>
Each &quot;0&quot; is &quot;false&quot; and once we hit a &quot;1&quot; in a vector, the answer to the question is &quot;true&quot;.
One-hot encoding transforms categorical features to a format that works better with classification and regression algorithms. It's very useful in methods where multiple types of data representation is necessary.
For example, some vectors may be optimal for regression (approximating functions based on former return values), and some may be optimal for classification (categorization into fixed sets/classes, typically binary):
<table class="table table-striped">
 <tr>
 <th>Label</th>
 <th>ID</th>
 </tr>
 <tr>
 <td>Strawberry</td>
 <td>1</td>
 </tr>
 <tr>
 <td>Apple</td>
 <td>2</td>
 </tr>
 <tr>
 <td>Watermelon</td>
 <td>3</td>
 </tr>
 <tr>
 <td>Lemon</td>
 <td>4</td>
 </tr>
 <tr>
 <td>Peach</td>
 <td>5</td>
 </tr>
 <tr>
 <td>Orange</td>
 <td>6</td>
 </tr>
</table>
Here we have six sample inputs of categorical data. The type of encoding used here is called &quot;label encoding&quot; - and it is very simple: we just assign an ID for a categorical value.
Our computer now knows how to represent these categories, because it knows how to work with numbers. However, this method of encoding is not very effective, because it tends to naturally give the higher numbers higher weights.
It wouldn't make sense to say that our category of &quot;Strawberries&quot; is greater or smaller than &quot;Apples&quot;, or that adding the category &quot;Lemon&quot; to &quot;Peach&quot; would give us a category &quot;Orange&quot;, since these values are not ordinal.
If we represented these categories in one-hot encoding, we would actually replace the rows with columns. We do this by creating one <code>boolean</code> column for each of our given categories, where only one of these columns could take on the value 1 for each sample:
<table class="table table-striped">
 <tr>
 <th>Strawberry</th>
 <th>Apple</th>
 <th>Watermelon</th>
 <th>Lemon</th>
 <th>Peach</th>
 <th>Orange</th>
 <th>ID</th>
 </tr>
 <tr>
 <td>1</td>
 <td>0</td>
 <td>0</td>
 <td>0</td>
 <td>0</td>
 <td>0</td>
 <td>1</td>
 </tr>
 <tr>
 <td>0</td>
 <td>1</td>
 <td>0</td>
 <td>0</td>
 <td>0</td>
 <td>0</td>
 <td>2</td>
 </tr>
 <tr>
 <td>0</td>
 <td>0</td>
 <td>1</td>
 <td>0</td>
 <td>0</td>
 <td>0</td>
 <td>3</td>
 </tr>
 <tr>
 <td>0</td>
 <td>0</td>
 <td>0</td>
 <td>1</td>
 <td>0</td>
 <td>0</td>
 <td>4</td>
 </tr>
 <tr>
 <td>0</td>
 <td>0</td>
 <td>0</td>
 <td>0</td>
 <td>1</td>
 <td>0</td>
 <td>5</td>
 </tr>
 <tr>
 <td>0</td>
 <td>0</td>
 <td>0</td>
 <td>0</td>
 <td>0</td>
 <td>1</td>
 <td>6</td>
 </tr>
</table>
We can see from the tables above that more digits are needed in one-hot representation compared to Binary or Gray code. For n digits, one-hot encoding can only represent n values, while Binary or Gray encoding can represent 2n values using n digits.
<h2 id="implementation">Implementation</h2>
<h3 id="pandas">Pandas</h3>
Let's take a look at a simple example of how we can convert values from a categorical column in our dataset into their numerical counterparts, via the one-hot encoding scheme.
We'll be creating a really simple dataset - a list of countries and their ID's:
<pre><code class="hljs">import pandas as pd

ids = [11, 22, 33, 44, 55, 66, 77]
countries = [&#x27;Spain&#x27;, &#x27;France&#x27;, &#x27;Spain&#x27;, &#x27;Germany&#x27;, &#x27;France&#x27;]

df = pd.DataFrame(list(zip(ids, countries)),
 columns=[&#x27;Ids&#x27;, &#x27;Countries&#x27;])
</code></pre>
In the script above, we create a Pandas dataframe, called <code>df</code> using two lists i.e. <code>ids</code> and <code>countries</code>. If you call the <code>head()</code> method on the dataframe, you should see the following result:
<pre><code class="hljs">df.head()
</code></pre>
<img src="https://stackabuse.s3.amazonaws.com/media/one-hot-encoding-in-python-with-pandas-and-scikit-learn-1.PNG" alt="dataframe header one hot encoding">
The <code>Countries</code> column contain categorical values. We can convert the values in the <code>Countries</code> column into one-hot encoded vectors using the <code>get_dummies()</code> function:
<pre><code class="hljs">y = pd.get_dummies(df.Countries, prefix=&#x27;Country&#x27;)
print(y.head())
</code></pre>
We passed <code>Country</code> as the value for the <code>prefix</code> attribute of the <code>get_dummies()</code> method, hence you can see the string <code>Country</code> prefixed before the header of each of the one-hot encoded columns in the output.
Running this code yields:
<pre><code class="hljs"> Country_France Country_Germany Country_Spain
0 0 0 1
1 1 0 0
2 0 0 1
3 0 1 0
4 1 0 0
</code></pre>
<h3 id="scikitlearn">Scikit-Learn</h3>
An alternative would be to use another popular library - Scikit-Learn. It offers both the <code>OneHotEncoder</code> class and the <code>LabelBinarizer</code> class for this purpose.
First, let's start by importing the <code>LabelBinarizer</code>:
<pre><code class="hljs">from sklearn.preprocessing import LabelBinarizer
</code></pre>
And then, using the same dataframe as before, let's instantiate the <code>LabelBinarizer</code> and fit it:
<pre><code class="hljs">y = LabelBinarizer().fit_transform(df.Countries)
</code></pre>
Printing <code>y</code> would yield:
<pre><code class="hljs">[[0 0 1]
 [1 0 0]
 [0 0 1]
 [0 1 0]
 [1 0 0]]
</code></pre>
Though, this isn't nearly as pretty as the Pandas approach.
Similarly, we can use the <code>OneHotEncoder</code> class, which supports multi-column data, unlike the previous class:
<pre><code class="hljs">from sklearn.preprocessing import OneHotEncoder
</code></pre>
And then, let's populate a list and fit it in the encoder:
<pre><code class="hljs">x = [[11, &quot;Spain&quot;], [22, &quot;France&quot;], [33, &quot;Spain&quot;], [44, &quot;Germany&quot;], [55, &quot;France&quot;]]
y = OneHotEncoder().fit_transform(x).toarray()
print(y)
</code></pre>
Running this will yield:
<pre><code class="hljs">[[1. 0. 0. 0. 0. 0. 0. 1.]
 [0. 1. 0. 0. 0. 1. 0. 0.]
 [0. 0. 1. 0. 0. 0. 0. 1.]
 [0. 0. 0. 1. 0. 0. 1. 0.]
 [0. 0. 0. 0. 1. 1. 0. 0.]]
</code></pre>
<h2 id="applicationsofonehotencoding">Applications of One-Hot Encoding</h2>
One-hot encoding has seen most of its application in the fields of Machine Learning and Digital Circuit Design.
<h3 id="machinelearning">Machine Learning</h3>
As stated above, computers aren't very good with categorical data. While we understand categorical data just fine, it's due to a kind of prerequisite knowledge that computers don't have.
Most Machine Learning techniques and models work with a very bounded dataset (typically binary). Neural networks consume data and produce results in the range of <code>0..1</code> and rarely will we ever go beyond that scope.
In short, the vast majority of machine learning algorithms receive sample data (&quot;training data&quot;) from which features are extracted. Based on these features, a mathematical model is created, which is then used to make predictions or decisions without being explicitly programmed to perform these tasks.
A great example would be <a target="_blank" href="/classification-in-python-with-scikit-learn-and-pandas/">Classification</a>, where the input can be technically unbounded, but the output is typically limited to a few classes. In the case of binary classification (say we're teaching a neural network to classify cats and dogs), we'd have a mapping of <code>0</code> for cats, and <code>1</code> for dogs.
Most of the time, the training data we wish to perform predictions on is categorical, like the example with fruit mentioned above. Again, while this makes a lot of sense to us, the words themselves are of no meaning to the algorithm as it doesn't understand them.
Using one-hot encoding for representation of data in these algorithms is not technically necessary, but pretty useful if we want an efficient implementation.
<h3 id="digitalcircuitdesign">Digital Circuit Design</h3>
Many basic digital circuits use one-hot notation in order to represent their I/O values.
For example, it can be used to indicate the state of a <a target="_blank" href="/theory-of-computation-finite-state-machines/">finite-state machine</a>. If some other type of representation, like Gray or Binary, is used, a decoder is needed to determine the state as they're not as naturally compatible. Contrarily, a one-hot finite-state machine does not need the decoder, because if the nth bit is high, the machine is, logically, in the nth state.
A good example of a finite-state machine is a ring counter - a type of counter composed of flip-flops connected to a shift register, in which the output of one flip-flop connects to the input of the other one.
The first flip-flop in this counter represents the first state, the second represents the second state, and so on. At the beginning, all of the flip-flops in the machine are set to '0', except for the first one, which is set to '1'.
The next clock edge arriving at the flip flops advances the one 'hot' bit to the second flip flop. The 'hot' bit advances like this until the last state, after which the machine returns to the first state.
Another example of usage of one-hot encoding in digital circuit design would be an address decoder, which takes a Binary or Gray code input, and then converts it to one-hot for the output, as well as a priority encoder (shown in the picture below).
It's the exact opposite and takes the one-hot input and converts it to Binary or Gray:
<img src="https://stackabuse.s3.amazonaws.com/media/one-hot-encoding-in-python-with-pandas-and-scikit-learn-2.jpg" alt="digital circuit design">
<h2 id="advantagesanddisadvantagesofonehotencoding">Advantages and Disadvantages of One-hot encoding</h2>
Like every other type of encoding, one-hot has many good points as well as problematic aspects.
<h3 id="advantages">Advantages</h3>
A great advantage of one-hot encoding is that determining the state of a machine has a low and constant cost, because all it needs to do is access one flip-flop. Changing the state of the machine is almost as fast, since it just needs to access two flip-flops.
Another great thing about one-hot encoding is the easy implementation. Digital circuits made in this notation are very easy to design and modify. Illegal states in the finite-state machine are also easy to detect.
A one-hot implementation is known for being the fastest one, allowing a state machine to run at a faster clock rate than any other encoding of that state machine.
<h3 id="disadvantages">Disadvantages</h3>
One of the main disadvantages that one-hot encoding has is the above mentioned fact that it can't represent many values (for n states, we would need n digits - or flip-flops). This is why, if we wanted to implement a one-hot 15-state ring counter for example, we would need 15 flip-flops, whereas the binary implementation would only need three flip-flops.
This makes it especially impractical for PAL devices, and it can also be very expensive, but it takes advantage of an FPGA's abundant flip-flops.
Another problem with this type of encoding is that many of the states in a finite-state machine would illegal - for every n valid states, there is (2n - n) illegal ones. A good thing is that these illegal states are, as previously said, really easy to detect (one XOR gate would be enough), so it's not very hard to take care of them.
<h2 id="conclusion">Conclusion</h2>
Since one-hot encoding is very simple, it is easy to understand and use in practice. It's no surprise that it is this popular in the world of computer science.
Due to the fact that the cons aren't too bad, its seen wide application. At the end of the day, its pros clearly outweigh the cons, which is why this type of implementation will definitely stick around for a long time in the future.

David Landup

Mila Lukic

One-Hot Encoding is a fundamental and common encoding schema used in Machine Learning and Data Science. In this article, we'll tackle One-Hot Encoding with Pandas and Scikit-Learn in Python.

One-Hot Encoding in Python with Pandas and Scikit-Learn

The MS Word utility from Microsoft Office suite is one of the most commonly used tools for writing text documents, both simple and complex. Though humans can easily read and write MS Word documents, assuming you have the Office software installed, oftentimes you need to read text from Word documents within another application.
For instance, if you are developing a <a target="_blank" href="/what-is-natural-language-processing/">natural language processing</a> application in Python that takes MS Word files as input, you will need to read MS Word files in Python before you can process the text. Similarly, oftentimes you need to write text to MS Word documents as output, which could be a dynamically generated report to download, for example.
In this article, you will see how to read and write MS Word files in Python.
<h2 id="installingthepythondocxlibrary">Installing the <code>python-docx</code> Library</h2>
Several libraries exist that can be used to read and write MS Word files in Python. However, we will be using the <a rel="nofollow noopener" target="_blank" href="https://python-docx.readthedocs.io/en/latest/">python-docx</a> module owing to its ease-of-use. Execute the following <code>pip</code> command in your terminal to download the <code>python-docx</code> module as shown below:
<pre><code class="hljs">$ pip install python-docx
</code></pre>
<h2 id="readingmswordfileswiththepythondocxmodule">Reading MS Word Files with the <code>python-docx</code> Module</h2>
In this section, you will see how to read text from MS Word files via the <code>python-docx</code> module.
Create a new MS Word file and rename it as &quot;my_word_file.docx&quot;. I saved the file in the root of my &quot;E&quot; directory, although you can save the file anywhere you want. The my_word_file.docx file should have the following content:
<img src="https://stackabuse.s3.amazonaws.com/media/reading-and-writing-ms-word-files-in-python-1.PNG" alt="reading ms word files in python">
To read the above file, first import the <code>docx</code> module and then create an object of the <code>Document</code> class from the <code>docx</code> module. Pass the path of the my_word_file.docx to the constructor of the <code>Document</code> class, as shown in the following script:
<pre><code class="hljs">import docx

doc = docx.Document(&quot;E:/my_word_file.docx&quot;)
</code></pre>
The <code>Document</code> class object <code>doc</code> can now be used to read the content of the my_word_file.docx.
<h3 id="readingparagraphs">Reading Paragraphs</h3>
Once you create an object of the <code>Document</code> class using the file path, you can access all the paragraphs in the document via the <code>paragraphs</code> attribute. An empty line is also read as a paragraph by the <code>Document</code>. Let's fetch all the paragraphs from the my_word_file.docx and then display the total number of paragraphs in the document:
<pre><code class="hljs">all_paras = doc.paragraphs
len(all_paras)
</code></pre>
Output:
<pre><code class="hljs">10
</code></pre>
Now we'll iteratively print all the paragraphs in the my_word_file.docx file:
<pre><code class="hljs">for para in all_paras:
 print(para.text)
 print(&quot;-------&quot;)
</code></pre>
Output:
<pre><code class="hljs">-------
Introduction
-------

-------
Welcome to stackabuse.com
-------
The best site for learning Python and Other Programming Languages
-------
Learn to program and write code in the most efficient manner
-------

-------
Details
-------

-------
This website contains useful programming articles for Java, Python, Spring etc.
-------
</code></pre>
The output shows all of the paragraphs in the Word file.
We can even access a specific paragraph by indexing the <code>paragraphs</code> property like an array. Let's print the 5th paragraph in the file:
<pre><code class="hljs">single_para = doc.paragraphs[4]
print(single_para.text)
</code></pre>
Output:
<pre><code class="hljs">The best site for learning Python and Other Programming Languages
</code></pre>
<h3 id="readingruns">Reading Runs</h3>
A run in a word document is a continuous sequence of words having similar properties, such as similar font sizes, font shapes, and font styles. For example, if you look at the second line of the my_word_file.docx, it contains the text <code>Welcome to stackabuse.com</code>, here the text <code>Welcome to</code> is in plain font, while the text <code>stackabuse.com</code> is in bold. Hence, the text <code>Welcome to</code> is considered as one run, while the bold faced text <code>stackabuse.com</code> is considered as another run.
Similarly, &quot;Learn to program and write code in the&quot; and &quot;most efficient manner&quot; are treated as two different runs in the paragraph &quot;Learn to program and write code in the most efficient manner&quot;.
To get all the runs in a paragraph, you can use the <code>run</code> property of the <code>paragraph</code> attribute of the <code>doc</code> object.
Let's read all the runs from paragraph number 5 (4th index) in our text:
<pre><code class="hljs">single_para = doc.paragraphs[4]
for run in single_para.runs:
 print(run.text)
</code></pre>
Output:
<pre><code class="hljs">The best site for
learning Python
 and Other
Programming Languages
</code></pre>
In the same way, the following script prints all the runs from the 6th paragraph of the my_word_file.docx file:
<pre><code class="hljs">second_para = doc.paragraphs[5]
for run in second_para.runs:
 print(run.text)
</code></pre>
Output:
<pre><code class="hljs">Learn to program and write code in the
most efficient manner
</code></pre>
<h2 id="writingmswordfileswiththepythondocxmodule">Writing MS Word Files with the <code>python-docx</code> Module</h2>
In the previous section, you saw how to read MS Word files in Python using the <code>python-docx</code> module. In this section, you will see how to write MS Word files via the <code>python-docx</code> module.
To write MS Word files, you have to create an object of the <code>Document</code> class with an empty constructor, or without passing a file name.
<pre><code class="hljs">mydoc = docx.Document()
</code></pre>
<h3 id="writingparagraphs">Writing Paragraphs</h3>
To write paragraphs, you can use the <code>add_paragraph()</code> method of the <code>Document</code> class object. Once you have added a paragraph, you will need to call the <code>save()</code> method on the <code>Document</code> class object. The path of the file to which you want to write your paragraph is passed as a parameter to the <code>save()</code> method. If the file doesn't already exist, a new file will be created, otherwise the paragraph will be appended at the end of the existing MS Word file.
The following script writes a simple paragraph to a newly created MS Word file named &quot;my_written_file.docx&quot;.
<pre><code class="hljs">mydoc.add_paragraph(&quot;This is first paragraph of a MS Word file.&quot;)
mydoc.save(&quot;E:/my_written_file.docx&quot;)
</code></pre>
Once you execute the above script, you should see a new file &quot;my_written_file.docx&quot; in the directory that you specified in the <code>save()</code> method. Inside the file, you should see one paragraph which reads &quot;This is the first paragraph of a MS Word file.&quot;
Let's add another paragraph to the my_written_file.docx:
<pre><code class="hljs">mydoc.add_paragraph(&quot;This is the second paragraph of a MS Word file.&quot;)
mydoc.save(&quot;E:/my_written_file.docx&quot;)
</code></pre>
This second paragraph will be appended at the end of the existing content in my_written_file.docx.
<h3 id="writingruns">Writing Runs</h3>
You can also write runs using the <code>python-docx</code> module. To write runs, you first have to create a handle for the paragraph to which you want to add your run. Take a look at the following example to see how it's done:
<pre><code class="hljs">third_para = mydoc.add_paragraph(&quot;This is the third paragraph.&quot;)
third_para.add_run(&quot; this is a section at the end of third paragraph&quot;)
mydoc.save(&quot;E:/my_written_file.docx&quot;)
</code></pre>
In the script above we write a paragraph using the <code>add_paragraph()</code> method of the <code>Document</code> class object <code>mydoc</code>. The <code>add_paragraph()</code> method returns a handle for the newly added paragraph. To add a run to the new paragraph, you need to call the <code>add_run()</code> method on the paragraph handle. The text for the run is passed in the form of a string to the <code>add_run()</code> method. Finally, you need to call the <code>save()</code> method to create the actual file.
<h3 id="writingheaders">Writing Headers</h3>
You can also add headers to MS Word files. To do so, you need to call the <code>add_heading()</code> method. The first parameter to the <code>add_heading()</code> method is the text string for header, and the second parameter is the header size. The header sizes start from 0, with 0 being the top level header.
The following script adds three headers of level 0, 1, and 2 to the file my_written_file.docx:
<pre><code class="hljs">mydoc.add_heading(&quot;This is level 1 heading&quot;, 0)
mydoc.add_heading(&quot;This is level 2 heading&quot;, 1)
mydoc.add_heading(&quot;This is level 3 heading&quot;, 2)
mydoc.save(&quot;E:/my_written_file.docx&quot;)
</code></pre>
<h3 id="addingimages">Adding Images</h3>
To add images to MS Word files, you can use the <code>add_picture()</code> method. The path to the image is passed as a parameter to the <code>add_picture()</code> method. You can also specify the width and height of the image using the <code>docx.shared.Inches()</code> attribute. The following script adds an image from the local file system to the my_written_file.docx Word file. The width and height of the image will be 5 and 7 inches, respectively:
<pre><code class="hljs">mydoc.add_picture(&quot;E:/eiffel-tower.jpg&quot;, width=docx.shared.Inches(5), height=docx.shared.Inches(7))
mydoc.save(&quot;E:/my_written_file.docx&quot;)
</code></pre>
After executing all the scripts in the Writing MS Word Files with the <code>python-docx</code> module section of this article, your final my_written_file.docx file should look like this:
<img src="https://stackabuse.s3.amazonaws.com/media/reading-and-writing-ms-word-files-in-python-2.PNG" alt="writing ms word files in python">
In the output, you can see the three paragraphs that you added to the MS word file, along with the three headers and one image.
<h2 id="conclusion">Conclusion</h2>
The article gave a brief overview of how to read and write MS Word files using the <code>python-docx</code> module. The article covers how to read paragraphs and runs from within a MS Word file. Finally, the process of writing MS Word files, adding a paragraph, runs, headers, and images to MS Word files have been explained in this article.

Usman Malik

The article explains how to read and write MS Word files with the Python-Docx module with the help of various examples. 

Reading and Writing MS Word Files in Python via Python-Docx Module

Multithreading often leads to headaches. In this article, we'll take a look at the often misunderstood volatile keyword in Java and how it's used in a multi-threaded environment.

Concurrency in Java: The volatile Keyword

Guest Contributor

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

Reading and Writing CSV Files in Python with Pandas

Janith Kasun

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

Guide to Handlebars: Templating Engine for Node/JavaScript

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

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

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

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

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

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

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

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

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

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

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