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

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

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

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

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

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

scaler = StandardScaler().fit(X)

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

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

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

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

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

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

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

seed = 42

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

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

grid_results = grid.fit(X_standardized, Y)

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

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

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

Muhammad Junaid Khalid

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

Grid Search Optimization Algorithm in Python

Janith Kasun

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

Integrating PostgreSQL with Node.js and node-postgres

Using PostgreSQL with Node.js and node-postgres

Usman Malik

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

Removing Stop Words from Strings in Python

Taimoor Choudhary

With HATEOAS, we can expose additional information in a single API call. In this article, we'll be building a Hypermedia-Driven RESTful web Service in Java and Spring HATEOAS.

Spring HATEOAS: Hypermedia-Driven RESTful Web Services

<h2 id="introduction">Introduction</h2>
From picking your cherished pair of jeans from your wardrobe to choosing the next movie to watch with your partner, human life is filled with searching for things.
While in day-to-day life, humans usually search between a few, if not a dozen, items. Computers have to deal with searching through data of comparatively massive amounts in terms of their size and quantity.
This warrants a computer's need to have an efficient method to search inside its arrays and collections as efficiently as possible.
Being able to find information amidst a collection is one of the most basic functional points of an application.
<h2 id="binarysearch">Binary Search</h2>
Binary Search (sometimes known as Logarithmic Search) is a widely popular algorithm to search a sorted array for the position of a given element.
It works on a divide and conquer basis by comparing the target element with the middle element of the array. In case a match is found - its position is returned, otherwise if the target element is smaller than the middle element, it can't be on the right side of the middle element.
Therefore, the right half of the array (including middle element) is discarded and the search is continued on the left half using the same approach.
Similarly in case the target element is larger than the middle element, it cannot be on a place preceding the middle of the array. Therefore, the left half of the array is discarded and the search is continued on the right half.
<blockquote>
This is repeated until a match is found.
</blockquote>
We can make this assumption simply because we know that the array is sorted beforehand. If it weren't sorted, we couldn't implement Binary Search.
Here's a visual representation of how Binary Search works:
<img src="https://stackabuse.s3.amazonaws.com/media/binary-search-in-java-1.gif" alt="binary search">
<h2 id="implementation">Implementation</h2>
Since we have a repeating step (checking for the middle element and discarding one half of the array), we can implement the algorithm using two approaches - an iterative approach and a recursive approach.
As usual, there's no clear winner between these two and you can choose to use any one of these based on your personal preference.
<h3 id="iterative">Iterative</h3>
Let's start off with the iterative implementation:
<pre><code class="hljs">public static int iterativeSearch(int[] arrayToSearch, int element) {
 int lowIndex = 0;
 int highIndex = arrayToSearch.length-1;

 // Holds the position in array for given element
 // Initial negative integer set to be returned if no match was found on array
 int elementPos = -1;

 // If lowIndex less than highIndex, there&#x27;s still elements in the array
 while (lowIndex &lt;= highIndex) {
 int midIndex = (lowIndex + highIndex) / 2;
 if (element == arrayToSearch[midIndex]) {
 elementPos = midIndex;
 break;
 } else if (element &lt; arrayToSearch[midIndex]) {
 highIndex = midIndex-1;
 } else if (element &gt; arrayToSearch[midIndex]) {
 lowIndex = midIndex+1;
 }
 }
 return elementPos;
}
</code></pre>
We need to keep track of the <code>lowIndex</code> (the first index) and the <code>highIndex</code> (last index) to get the arithmetic middle for the array. The <code>elementPos</code> by default is <code>-1</code> which signifies that the element hasn't been found.
If it hasn't, we simply return this position. If it has, we adjust the <code>elementPos</code> to reflect the location in the array.
Then, through a <code>while</code> loop, we check if the middle element is the one we're searching for. If not, we adjust the <code>lowIndex</code> and <code>highIndex</code> to disregard the half of the array that the target element isn't in.
<h3 id="recursive">Recursive</h3>
The recursive implementation is fairly straightforward too, but we simply call the method recursively until the element has been found:
<pre><code class="hljs">public static int recursiveSearch(int[] arrayToSearch, int element) {
 return recursiveSearch(arrayToSearch, element, 0, arrayToSearch.length-1);
}

private static int recursiveSearch(int[] arrayToSearch, int element, int lowIndex, int highIndex) {
 // If lowIndex surpasses highIndex, the element has not been found
 if (lowIndex &gt; highIndex) return -1;

 // Default assumption is that the element is not found
 int elementPos = -1;

 int midIndex = (lowIndex + highIndex) / 2;

 if (element == arrayToSearch[midIndex]) {
 elementPos = midIndex;
 } else if (element &lt; arrayToSearch[midIndex]) {
 recursiveSearch(arrayToSearch, element, lowIndex, midIndex-1);
 } else if (element &gt; arrayToSearch[midIndex]) {
 recursiveSearch(arrayToSearch, element, midIndex+1, highIndex);
 }
 return elementPos;
}
</code></pre>
<h2 id="benchmarkingbinarysearch">Benchmarking Binary Search</h2>
To analyze how efficiently Binary Search algorithm works with given integer datasets, let's run the code against integer arrays of varied sizes and observe the runtimes it takes for a binary search to find a given number, expressed in nanoseconds:
<table class="table table-striped">
 <tr>
 <th>Array Size</th>
 <th>1st run (ns)</th>
 <th>2nd run (ns)</th>
 <th>3rd run (ns)</th>
 <th>Average (ns)</th>
 </tr>
 <tr>
 <td>10</td>
 <td>568,500</td>
 <td>755,000</td>
 <td>644,700</td>
 <td>656,066</td>
 </tr>
 <tr>
 <td>100</td>
 <td>846,100</td>
 <td>713,000</td>
 <td>724,100</td>
 <td>761,066</td>
 </tr>
 <tr>
 <td>1000</td>
 <td>1,323,600</td>
 <td>942,900</td>
 <td>735,800</td>
 <td>1,000,766</td>
 </tr>
</table>
<h2 id="bigoanalysis">Big-O Analysis</h2>
On each of its search iterations, Binary Search halves the set of items it searches. This leads the Binary Search algorithm to retain a worst case efficiency of logarithmic time. In <a target="_blank" href="/big-o-notation-and-algorithm-analysis-with-python-examples/">Big-O Notation terms</a>, an O(log n) complexity.
More so, in case the target element was found in the very middle of the array on the first go, the operation would have completed in linear time. From that we can deduce that Binary Search has a best case efficiency of O(1).
Therefore, conclusively Binary Search algorithm has an average performance of O(log n) .
It's also critical to mention that although the algorithm is greatly effective for searching arrays, its logic requires the searched array to be sorted beforehand.
In case you plan to use the algorithm on an unsorted array, you would have to sort it first - causing an increased complexity. In this case even a typical linear search would typically dominate Binary Search with its O(n) complexity.
<h2 id="conclusion">Conclusion</h2>
Since first being mentioned way back in 1946 by <a rel="nofollow noopener" target="_blank" href="https://en.wikipedia.org/wiki/John_Mauchly">John Mauchly</a>, Binary Search has been preserved to this date as an easy-to-understand and highly efficient algorithm for searching sorted arrays for positions of its target elements.
It works on a divide and conquer basis by comparing the target element with the middle element of the array. In this article, we've implemented both the Iterative and Recursive approaches and benchmarked the algorithm with three different sets of integers.
Additionally, we've done a quick Big-O Analysis to prove the efficiency of this basic, yet effective search algorithm.

Dasun Nirmitha

Binary Search is a really simple yet effective searching algorithm. In this article, we'll implement iterative and recursive Binary Search in Java and analyze its performance.

Binary Search in Java

<h2 id="introduction">Introduction</h2>
Design patterns are a collection of programming methodologies used in day-to-day programming. They represent solutions to some commonly occurring problems in the programming industry, which have intuitive solutions.
Sooner or later, a desktop program, mobile app, or some other type of software will inevitably become complex and start exhibiting certain kinds of problems. These problems are typically related to the complexity of our codebase, non-modularity, inability to separate certain parts from each other, etc.
For this reason, design patterns have become the de facto standard in the programming industry since their initial use a few decades ago due to their ability to solve many of these problems. In this article, we will dive deeper into one of these methodologies - namely, the Factory Method Pattern.
<h2 id="creationaldesignpatterns">Creational Design Patterns</h2>
The Factory Method Pattern is one of several <a target="_blank" href="/creational-design-patterns-in-java/">Creational Design Patterns</a> we often use in Java. Their purpose is to make the process of creating objects simpler, more modular, and more scalable.
These patterns control the way we define and design the objects, as well as how we instantiate them. Some encapsulate the creation logic away from users and handles creation (<a target="_blank" href="/creational-design-patterns-in-java/#factorymethod">Factory</a> and <a target="_blank" href="/creational-design-patterns-in-java/#abstractfactory">Abstract Factory</a>), some focus on the process of building the objects themselves (<a target="_blank" href="/the-builder-design-pattern-in-java/">Builder</a>), some minimize the cost of creation (<a target="_blank" href="/creational-design-patterns-in-java/#prototype">Prototype</a>) and some control the number of instances on the whole JVM (<a target="_blank" href="/creational-design-patterns-in-java/#singleton">Singleton</a>).
Specifically, the Factory Method and Abstract Factory are very common in Java software development.
<h2 id="thefactorymethodpattern">The Factory Method Pattern</h2>
The Factory Method Pattern (also known as the Virtual Constructor or Factory Template Pattern) is a creational design pattern used in object-oriented languages.
The main idea is to define an interface or abstract class (a factory) for creating objects. Though, instead of instantiating the object, the instantiation is left to its subclasses.
Each object is created through a factory method available in the factory - which can either be an interface or an abstract class.
If the factory is an interface - the subclasses must define their own factory methods for creating objects because there is no default implementation.
If the factory is a class - the subclasses can use existing implementation or optionally override factory methods.
With the Factory Pattern, the object creation logic is hidden from the client. Instead of knowing the exact object class and instantiating it through a constructor, the responsibility of creating an object is moved away from the client.
The client can then create objects through a common interface which simplifies the process.
This approach separates the object creation from the implementation, which promotes loose coupling and thus easier maintenance and upgrades.
<h2 id="motivation">Motivation</h2>
After some theoretical introduction, let's see the Factory Pattern in practice.
Imagine we're trying to build our own spaceship. Since this is a simplified example, we'll also simplify the construction and say that our spaceship consists of a hull, an <code>Engine</code>, and a satellite <code>Dish</code>:
<pre><code class="hljs">public class SpaceshipHangar {
 public Spaceship createSpaceship() {
 Spaceship ship = new Spaceship();
 Engine engine = new SublightEngine();
 Dish dish = new RoundDish();

 ship.setEngine(engine);
 ship.setDish(dish);

 return ship;
 }
}
</code></pre>
Note: <code>SublightEngine</code> and <code>RoundDish</code> are subclasses of <code>Engine</code> and <code>Dish</code>, respectively.
Now imagine that you showed your new spaceship to a friend, and suddenly they want a spaceship of their own too. But instead of the <code>SublightEngine</code> they want to put a <code>HyperdriveEngine</code>, and instead of the <code>RoundDish</code> they want to put a <code>SquareDish</code>:
<pre><code class="hljs">public class SpaceshipHangar {
 public Spaceship createSpaceship() {
 Spaceship ship = new Spaceship();
 Engine engine = new HyperdriveEngine();
 Dish dish = new SquareDish();

 ship.setEngine(engine);
 ship.setDish(dish);

 return ship;
 }
}
</code></pre>
Since the instantiations are hard-coded, you could either create a duplicate of your original method or change its code.
If you duplicate the method each time someone else wants to make a slight modification to the ship, this quickly becomes a problem because you will have lots of almost identical methods with minimal difference.
If you change the original code, then the method itself looses the point because it needs to be rewritten every time someone wants to make a small change to the ship.
This goes on as you add more related variations of a logical collection - all spaceships for instance.
<h2 id="implementation">Implementation</h2>
To solve this problem, we can create a Factory of spaceships and leave the specifics (which engine or dish is used) to the subclasses to define.
Instead of hard-coding object creation into the <code>createSpaceship()</code> method with <code>new</code> operators, we'll create a <code>Spaceship</code> interface and implement it through a couple of different concrete classes.
Then, using a <code>SpaceshipFactory</code> as our communication point with these, we'll instantiate objects of <code>Spaceship</code> type, though, implemented as concrete classes. This logic will stay hidden from the end user, as we'll be specifying which implementation we want through the argument passed to the <code>SpaceshipFactory</code> method used for instantiation.
Let's start off with the <code>Spaceship</code> interface:
<pre><code class="hljs">public interface Spaceship {
 void setEngine(Engine engine);
 void setDish(Dish dish);
}
</code></pre>
Since we're working with the <code>Engine</code> and <code>Dish</code> classes, let's define them real quick:
<pre><code class="hljs">public class Engine {
 private String model;

 public Engine(String model) {
 this.model = model;
 }

 // Getters and Setters
}

public class Dish {
 private String model;

 public Dish(String model) {
 this.model = model;
 }

 // Getters and Setters
}
</code></pre>
And now, let's implement the interface through two concrete implementations, starting with the <code>SpaceshipMk1</code>:
<pre><code class="hljs">public class SpaceshipMk1 implements Spaceship {
 private Engine engine;
 private Dish dish;

 public SpaceshipMk1(Engine engine, Dish dish) {
 this.engine = engine;
 System.out.println(&quot;Powering up the Mk.1 Raptor Engine&quot;);

 this.dish = dish;
 System.out.println(&quot;Activating the Mk.1 Satellite Dish&quot;);
 }

 @Override
 public void setEngine(Engine engine) {
 this.engine = engine;
 }

 @Override
 public void setDish(Dish dish) {
 this.dish = dish;
 }
}
</code></pre>
And the <code>SpaceshipMk2</code>:
<pre><code class="hljs">public class SpaceshipMk2 implements Spaceship {
 private Engine engine;
 private Dish dish;

 public SpaceshipMk2(Engine engine, Dish dish) {
 this.engine = engine;
 System.out.println(&quot;Powering up the Mk.2 Raptor Engine&quot;);

 this.dish = dish;
 System.out.println(&quot;Activating the Mk.2 Satellite Dish&quot;);
 }

 @Override
 public void setEngine(Engine engine) {
 this.engine = engine;
 }

 @Override
 public void setDish(Dish dish) {
 this.dish = dish;
 }
}
</code></pre>
Now, instead of simply instantiating these as we typically would, let's create a <code>SpaceshipFactory</code> for them:
<pre><code class="hljs">public class SpaceshipFactory {
 public Spaceship getSpaceship(Engine engine, Dish dish) {
 if (engine.getModel().equals(&quot;Mk.2&quot;) &amp;&amp; dish.getModel().equals(&quot;Mk.2&quot;)) {
 return new SpaceshipMk2(engine, dish);
 } else if (engine.getModel().equals(&quot;Mk.1&quot;) &amp;&amp; dish.getModel().equals(&quot;Mk.1&quot;)) {
 return new SpaceshipMk1(engine, dish);
 } else {
 System.out.println(&quot;Incompatible models of engine and satellite dish.&quot;);
 }
 return null;
 }
}
</code></pre>
The factory typically has a single method called <code>getTypeName()</code> with the parameters you'd wish to pass. Then, through as many <code>if</code> statements required, we check which exact class should be used to serve the call.
And with this factory in place, when we'd like to instantiate any of these two spaceship classes, we use the factory:
<pre><code class="hljs">SpaceshipFactory factory = new SpaceshipFactory();

Engine engineMk1 = new Engine(&quot;Mk.1&quot;);
Dish dishMk1 = new Dish(&quot;Mk.1&quot;);

Engine engineMk2 = new Engine(&quot;Mk.2&quot;);
Dish dishMk2 = new Dish(&quot;Mk.2&quot;);

Spaceship spaceshipMk1 = factory.getSpaceship(engineMk1, dishMk1);
Spaceship spaceshipMk2 = factory.getSpaceship(engineMk2, dishMk2);
Spaceship spaceshipMkHybrid = factory.getSpaceship(engineMk1, dishMk2);
</code></pre>
Here, instead of using the <code>new</code> operator to instantiate either spaceship, we call upon the common interface <code>Spaceship</code> and using the factory construct/instantiate the objects. Running this code would yield:
<pre><code class="hljs">Powering up the Mk.1 Raptor Engine
Activating the Mk.1 Satellite Dish
Powering up the Mk.2 Raptor Engine
Activating the Mk.2 Satellite Dish
Incompatible models of engine and satellite dish.
</code></pre>
Note: Ideally, we'd also have factories for engines and dishes, especially if we have derived types such as <code>HyperdriveEngine</code> and <code>SquareDish</code>. Having multiple factories would end up with multiple <code>new</code> keywords - which is against what the Factory Method stands for.
<blockquote>
What is the fix then? Haven't we only made a roundabout and ended up with the same problem?
</blockquote>
That's where the <a target="_blank" href="/creational-design-patterns-in-java/#abstractfactory">Abstract Factory Design Pattern</a> jumps in. It's like a factory of factories which would, using the same approach, instantiate all spaceship-related factories with only a single <code>new</code> call at the start.
<h2 id="prosandcons">Pros and Cons</h2>
<h3 id="pros">Pros</h3>
<ul>
<li>Allows loosely-coupled code, making changes less disruptive</li>
<li>Easy to unit test and mock as code is decoupled</li>
</ul>
<h3 id="cons">Cons</h3>
<ul>
<li>Makes code less readable since all object creation code is behind a layer of abstraction</li>
<li>If used with the Abstract Factory Pattern (a factory of factories), the code quickly becomes cumbersome but functional</li>
</ul>
<h2 id="conclusion">Conclusion</h2>
The Factory Method and other design patterns are tested and proven-to-work techniques. Regardless if used in personal projects or very large industry codebases. They offer clever solutions to some common problems and encourage developers and entire teams to do architecture design first, programming second. This almost always leads to a higher-quality code rather than jumping right into programming.
It's a misconception that design patterns are holy solutions to all problems. Design patterns are techniques to help mitigate some common problems, invented by people who have solved these problems numerous times.

Luka Čupić

The Factory Method Pattern is a creational design pattern used in OO languages. In this article, we'll be diving into the theory and implementation of The Factory Method/Template. 

Factory Method Design Pattern in Java

Software development is inherently full of challenges. This ranges from architecting your software, maintaining it, fixing bugs, deploying, and the list goes on. When starting out, you'd think that the easy part would be to share you code with others. After all, they're just text files, right? This may not be too difficult with extremely simple programs that have only one developer, but issues compound as the number of collaborators grows, as well as the size of the project.
For example, how do you share updates to a codebase with another developer working on the same project? Would you constantly email changed files back and forth? What if you're working on the same files simultaneously? How do you detect and merge these changes?
This was exactly why <a rel="nofollow noopener" target="_blank" href="https://en.wikipedia.org/wiki/Version_control">version control</a> systems (VCS) were created, to allow simultaneous collaboration, sharing, and merging of changes to a project.
While there are a number of version control systems out there, like <a rel="nofollow noopener" target="_blank" href="https://en.wikipedia.org/wiki/Concurrent_Versions_System">CVS</a>, <a rel="nofollow noopener" target="_blank" href="https://en.wikipedia.org/wiki/Apache_Subversion">SVN</a>, <a rel="nofollow noopener" target="_blank" href="https://en.wikipedia.org/wiki/Mercurial">Mercurial</a>, etc., <a rel="nofollow noopener" target="_blank" href="https://en.wikipedia.org/wiki/Git">Git</a> has emerged as the most popular system by far.
Git, a distributed version control, was released in 2005 and created by Linus Torvalds, who is also the creator of Linux. It is so popular that it's at the core of multiple multi-billion dollar companies, like GitHub, GitLab, and Atlassian's BitBucket, which host public and private Git repositories.
With Git being so popular among developers, it's an essential skill to learn. In this article, we'll cover the basics of what Git is, how it works, and where you can find resources to learn more.
<h2 id="whatisgit">What is Git?</h2>
Various VCSs have different structures. Take SVN for example, which is a centralized repository, meaning it has one &quot;master&quot; repository. This differs from Git, which is decentralized and has no master. In practice, a single hosted repository is usually shared among a team, but projects can be more easily forked and not have any dependency on the original repo.
This is a big reason for Git's popularity, it isn't inherently constrained by its architecture, and it has some features (like branching and merging) that are &quot;first class citizens&quot;, as opposed to being an after-thought like in other VCSs.
You typically interact with Git through the command line tool, appropriately named <code>git</code>. Although, there are now quite a few GUI tools out there (i.e. <a rel="nofollow noopener" target="_blank" href="https://desktop.github.com/">GitHub Desktop</a>, <a rel="nofollow noopener" target="_blank" href="https://www.sourcetreeapp.com/">SourceTree</a>, and <a rel="nofollow noopener" target="_blank" href="https://www.gitkraken.com/">GitKraken</a>) that helps you use some of the more common features, like committing, branching, and merging. With Git being a bit complex to use, some beginners opt to start off with these GUI tools. And while they can be extremely useful and help you be productive, I'd recommend you at least become comfortable with the command line version as well to deepen your understanding.
Git works by tracking what changed in each file in a project, who made that change, and why. Internally, this is done in a graph structure, and each new commit creates a new node in the graph.
<img alt="git master tree" src="https://stackabuse.s3.amazonaws.com/media/git-an-introduction-beginners-1.svg">
A branch in Git creates a new node off of the main tree (the yellow node in the image below) in which you can make any change you want without affecting the main codebase. This way other developers can continue to work on their new features in separate branches while you work on yours, all without disrupting the progress of one another.
<img alt="git tree with branch" src="https://stackabuse.s3.amazonaws.com/media/git-an-introduction-beginners-2.svg">
Once you've finished the updates on your branch, you can then merge it back in to the master branch. When this is done, everyone else working in the same repository will then pull in your changes to their local systems. By making changes in this way, you avoid disrupting the main branch.
<img alt="git tree with merged branch" src="https://stackabuse.s3.amazonaws.com/media/git-an-introduction-beginners-3.svg">
<h2 id="gitbasics">Git Basics</h2>
Git can be complicated, which is probably why you're here. Because of that, we'll just cover a few of the main features of the command-line tool here, and provide resources if you want to dive deeper in to each function.
First of all, to get started you'll want to install <code>git</code> on your system. Most Mac and Linux distributions come with Git pre-installed, but just in case yours doesn't, here is how to do it:
MacOS
Install Git with either the <a rel="nofollow noopener" target="_blank" href="https://www.ics.uci.edu/~pattis/common/handouts/macmingweclipse/allexperimental/macxcodecommandlinetools.html">Xcode Command Line Tools</a> or using the installer from <a rel="nofollow noopener" target="_blank" href="https://git-scm.com/download/mac">this link</a>.
Debian-based Distros
<pre><code class="hljs">$ sudo apt install git-all
</code></pre>
RPM-based Distros
<pre><code class="hljs">$ sudo dnf install git-all
</code></pre>
Windows
<a rel="nofollow noopener" target="_blank" href="https://git-scm.com/download/win">Download the installer</a> for Git for Windows and follow the instructions.
Once installed, you can create a new repository by entering the directory of your project (a Node.js project in our example) and using the <code>init</code> command:
<pre><code class="hljs">$ cd my-project
$ git init
</code></pre>
This will initialize Git, but before anything is tracked, you need to explicitly add your project files to the repo:
<pre><code class="hljs">$ git add package.json config.json
</code></pre>
Git makes this process a bit easier and allows wildcards to select files in bulk:
<pre><code class="hljs">$ git add src/*.js
</code></pre>
Now, our files aren't yet committed to Git, they're just staged. We can view staged files using the <code>status</code> command:
<pre><code class="hljs">$ git status
On branch master

Initial commit

Changes to be committed:
 (use &quot;git rm --cached &lt;file&gt;...&quot; to unstage)

 new file: config.json
 new file: package.json
 new file: src/index.js
 new file: src/api.js
</code></pre>
Now we're ready to commit our changes to the repository using the <code>commit</code> command:
<pre><code class="hljs">$ git commit -am &quot;Initial commit&quot;
</code></pre>
The <code>-a</code> flag tells Git to commit all staged files, and the <code>-m</code> flag let's us add a commit message via the command line. If this is omitted then your default text editor will open, allowing you to enter the message there. This message is used to describe what changes took place.
From here you can do a lot of things, like, for example, tagging the commit with a version number, creating a branch to work on a new feature, or reverting back to an older commit if you made a mistake.
To complete our short example, let's push our changes to a remote repository, allowing other developers to get the changes. For this to work, we first need to create a repository on GitHub account, which we can then use to push to:
<pre><code class="hljs">$ git remote add origin https://github.com/scottwrobinson/my-project.git
$ git push origin master
</code></pre>
The first command above tells Git the location of our remote repository, which we've named &quot;origin&quot;. In the second command, we tell Git to push our code from the master branch to our origin server. Depending on how you've set up your GitHub account, you may be required to enter a password or specify an SSH key.
While it's helpful to see the basics of using a complicated tool like Git, there is still a lot to learn and this example just scratches the surface of what Git is capable of. Many of these features are out of the scope of this article, so we've provided a number of resources that dive in to more detail on more specific Git topics.
<h2 id="resourcestolearnmore">Resources to Learn More</h2>
<ul>
<li><a target="_blank" href="/git-create-a-new-repository/">Create a Git Repository</a></li>
<li><a target="_blank" href="/git-clone-a-repository/">Clone a Repository</a></li>
<li><a target="_blank" href="/git-create-a-new-branch/">Create a New Branch</a></li>
<li><a target="_blank" href="/git-checkout-a-remote-branch/">Checkout a Remote Branch</a></li>
<li><a target="_blank" href="/git-add-all-files-to-a-repo/">Add All Files to a Repo</a></li>
<li><a target="_blank" href="/git-merge-branch-into-master/">Merge Branch into Master</a></li>
<li><a target="_blank" href="/git-delete-branch-locally-and-remotely/">Delete Branch Locally and Remotely</a></li>
<li><a target="_blank" href="/git-push-local-branch-and-track-it/">Push Local Branch and Track it</a></li>
</ul>
For even more articles on the subject, check out all of our <a target="_blank" href="/tag/git/">Git articles</a>.

Scott Robinson

An introduction to Git, which covers the basics of what Git is, how it works, and where you can find resources to learn more.

Git: An Introduction for Beginners

Tom Kadwill

Sequelize is a popular and stable ORM used with Node.js. In this article, we'll be setting up a note-management app that performs CRUD operations against the database using Sequelize.

Using Sequelize ORM with Node.js and Express

As many programmers have found out the hard way, adding documentation is extremely important in being able to easily make modifications to your code, fix issues, pass off to others, etc. Just because your code makes sense now doesn't mean it'll make sense to you in 6 months (or even a week, really). You're probably used to documenting your actual code, but this same practice should also be followed with your version control commits as well.
In Git, there are a few ways to document your changes, but we'll be focusing mostly on how to do it for individual commits in this short article.
When viewing a repository on GitHub, you have probably noticed the messages next to a file or folder:
<img src="https://stackabuse.s3.amazonaws.com/media/git-adding-commit-message-1.png" alt="git commit messages in github">
These messages are typically added to the repository at the time in which you make the commit, although you can retroactively add commit messages as well.
In GitHub, the message next to the file or folder is from the last commit in which that file/folder changed. So these are not all necessarily from the last commit. Otherwise it wouldn't be very useful if GitHub displayed the same commit message from the last commit for all files.
In order to add this message, you need to specify the <code>-m</code> flag when executing <code>git commit</code>. Your message should immediately follow the flag and be wrapped in quotation marks. An example of this looks like this:
<pre><code class="hljs">$ git commit index.js -m &quot;Fixed world-ending bug (#281)&quot;
</code></pre>
<h2 id="multilinemessages">Multi-Line Messages</h2>
You can't always describe a complex change with a short, single-line comment. An interesting feature of the <code>-m</code> flag is that you can add multiple paragraphs to your message by using the <code>-m</code> flag multiple times in the same <code>commit</code> command:
<pre><code class="hljs">$ git commit index.js -m &quot;My Changes&quot; -m &quot;- Fixed a critical bug&quot; -m &quot;- Probably added more bugs&quot;
</code></pre>
These multiple messages will then look like this in the resulting commit:
<pre><code class="hljs">My Changes
- Fixed a critical bug
- Probably added more bugs
</code></pre>
Another option, which depends on the shell you're using, is to just enter a single or double quote and press <kbd>Enter</kbd>, without closing the quote. This works well in Bash, which doesn't enter the command until you've closed the quote:
<pre><code class="hljs">$ git commit index.js -m &quot;My Changes
- Fixed a critical bug
- Probably added more bugs
&quot;
</code></pre>
And finally, you don't actually need to use the <code>-m</code> flag at all. If you omit this flag then Git will automatically open a text editor for you to enter the commit message.

Adding documentation is important in being able to easily make modifications to your code, fix issues, pass it off to others, etc. In Git, there are a few ways to document your changes.