Darinka Zobenica

In this tutorial, we'll implement many sort algorithms in Java with examples. 
This includes, Bubble Sort, Insertion Sort, Selection Sort, Merge Sort, Heap Sort and Quick Sort.

Sorting Algorithms in Java

<h2 id="introduction">Introduction</h2>
<a rel="nofollow" target="_blank" href="https://www.postgresql.org/">PostgreSQL</a> is one of the most advanced and widely used relational database management systems. It's extremely popular for many reasons, a few of which include it being open source, its extensibility, and its ability to handle many different types of applications and varying loads.
With Python, you can easily establish a connection to your PostgreSQL database. There are many Python drivers for PostgreSQL, with &quot;psycopg&quot; being the most popular one. Its current version is <code>psycopg2</code>.
In this article, we'll be discussing how to access a PostgreSQL database in Python using the <code>psycopg2</code> driver.
<h2 id="thepsycopg2module">The <code>psycopg2</code> Module</h2>
We can integrate Postgres with Python using the <a rel="nofollow" target="_blank" href="https://www.psycopg.org/docs/install.html">psycopg2</a> module. <code>psycopg2</code> is a Postgres database adapter for Python. To use this module, you should first install it. This can be done using the <code>pip</code> command, as shown below:
<pre><code class="hljs">$ pip3 install psycopg2
</code></pre>
Note that I am using Python 3.5, hence I have used <code>pip3</code> instead of <code>pip</code>.
Once the module has been installed, you can use it to connect to your database in your application.
<h2 id="connectingtoadatabase">Connecting to a Database</h2>
To connect to your database, you should first create a connection object representing the database. Next, you should create a cursor object to help you in execution of your SQL statements.
The following example demonstrates how to establish a connection to the database named &quot;postgres&quot;:
<pre><code class="hljs">import psycopg2

con = psycopg2.connect(database=&quot;postgres&quot;, user=&quot;postgres&quot;, password=&quot;&quot;, host=&quot;127.0.0.1&quot;, port=&quot;5432&quot;)

print(&quot;Database opened successfully&quot;)
</code></pre>
Output:
<pre><code class="hljs">Database opened successfully
</code></pre>
The following is the list of parameters that have been passed to the <code>connect()</code> method:
<ul>
<li><code>database</code>: The name of the database you need to connect to.</li>
<li><code>user</code>: The username to be used for authentication.</li>
<li><code>password</code>: The database password for the user.</li>
<li><code>host</code>: The address of the database server. For example, a domain name, &quot;localhost&quot;, or an IP address.</li>
<li><code>port</code>: The port number. If you don't provide this, the default one will be used, which is 5432.</li>
</ul>
Note that the values for the above parameters should be correct for the connection to be successful. If not, an exception will be generated. The output in the above code shows that the connection to the database has been established successfully.
<h2 id="creatingatable">Creating a Table</h2>
To create a Postgres table in Python, we use the <code>CREATE TABLE</code> SQL statement. This query should be executed after establishing a connection to the database. We also create a cursor object by calling the <code>cursor()</code> method that belongs to the <code>connection</code> object. This <code>cursor</code> object is used to actually execute your commands.
We then call the <code>execute()</code> method of the <code>cursor</code> object to help us in creating the table. Finally, we need to commit and close the connection. &quot;Committing&quot; the connection tells the driver to send the commands to the database.
The following example demonstrates this:
<pre><code class="hljs">import psycopg2

con = psycopg2.connect(database=&quot;postgres&quot;, user=&quot;postgres&quot;, password=&quot;Kaliakakya&quot;, host=&quot;127.0.0.1&quot;, port=&quot;5432&quot;)
print(&quot;Database opened successfully&quot;)

cur = con.cursor()
cur.execute(&#x27;&#x27;&#x27;CREATE TABLE STUDENT
 (ADMISSION INT PRIMARY KEY NOT NULL,
 NAME TEXT NOT NULL,
 AGE INT NOT NULL,
 COURSE CHAR(50),
 DEPARTMENT CHAR(50));&#x27;&#x27;&#x27;)
print(&quot;Table created successfully&quot;)

con.commit()
con.close()
</code></pre>
Output
<pre><code class="hljs">Database opened successfully
Table created successfully
</code></pre>
The <code>commit()</code> method helps us apply the changes that we have made to the database, and these changes cannot be undone if <code>commit()</code> runs successfully. The <code>close()</code> method will close the connection to the database.
At this point we have created a table with 4 columns, all of which have various data types. The above output shows that the table was created successfully.
<h2 id="insertingdata">Inserting Data</h2>
We can insert either a single record or multiple records into a Postgres database table. Again, we must first establish a connection to the database server by calling the <code>connect()</code> function. Next, we should create a cursor object by calling the <code>cursor()</code> method. Lastly, we should run the <code>INSERT</code> statement via the <code>execute()</code> method to add the data into the table.
Here is an example of this in action:
<pre><code class="hljs">import psycopg2

con = psycopg2.connect(database=&quot;postgres&quot;, user=&quot;postgres&quot;, password=&quot;Kaliakakya&quot;, host=&quot;127.0.0.1&quot;, port=&quot;5432&quot;)
print(&quot;Database opened successfully&quot;)

cur = con.cursor()

cur.execute(&quot;INSERT INTO STUDENT (ADMISSION,NAME,AGE,COURSE,DEPARTMENT) VALUES (3420, &#x27;John&#x27;, 18, &#x27;Computer Science&#x27;, &#x27;ICT&#x27;)&quot;);

con.commit()
print(&quot;Record inserted successfully&quot;)
con.close()
</code></pre>
Output
<pre><code class="hljs">Database opened successfully
Record inserted successfully
</code></pre>
After running this code we have inserted a single record into our database table. This was done by specifying the name of the table as well as the columns into which we need to insert the data into. It is also possible for us to insert multiple records with one command. For example:
<pre><code class="hljs">import psycopg2

con = psycopg2.connect(database=&quot;postgres&quot;, user=&quot;postgres&quot;, password=&quot;Kaliakakya&quot;, host=&quot;127.0.0.1&quot;, port=&quot;5432&quot;)
print(&quot;Database opened successfully&quot;)

cur = con.cursor()

cur.execute(&quot;INSERT INTO STUDENT (ADMISSION,NAME,AGE,COURSE,DEPARTMENT) VALUES (3419, &#x27;Abel&#x27;, 17, &#x27;Computer Science&#x27;, &#x27;ICT&#x27;)&quot;);
cur.execute(&quot;INSERT INTO STUDENT (ADMISSION,NAME,AGE,COURSE,DEPARTMENT) VALUES (3421, &#x27;Joel&#x27;, 17, &#x27;Computer Science&#x27;, &#x27;ICT&#x27;)&quot;);
cur.execute(&quot;INSERT INTO STUDENT (ADMISSION,NAME,AGE,COURSE,DEPARTMENT) VALUES (3422, &#x27;Antony&#x27;, 19, &#x27;Electrical Engineering&#x27;, &#x27;Engineering&#x27;)&quot;);
cur.execute(&quot;INSERT INTO STUDENT (ADMISSION,NAME,AGE,COURSE,DEPARTMENT) VALUES (3423, &#x27;Alice&#x27;, 18, &#x27;Information Technology&#x27;, &#x27;ICT&#x27;)&quot;);

con.commit()
print(&quot;Records inserted successfully&quot;)
con.close()
</code></pre>
Output
<pre><code class="hljs">Database opened successfully
Records inserted successfully
</code></pre>
Since the <code>commit()</code> method isn't called until after we &quot;execute&quot; all of the <code>INSERT</code> statements, multiple records are inserted with a single call of the <code>commit()</code> method.
<h2 id="retrievingdata">Retrieving Data</h2>
You can select data from a Postgres database and view the table records. First, you must establish a connection to the database using the <code>connect()</code> function. Next, a new cursor should be created by calling the <code>cursor()</code> method. The created cursor object can then be used to execute the <code>SELECT</code> statement for querying data from the database.
For example:
<pre><code class="hljs">import psycopg2

con = psycopg2.connect(database=&quot;postgres&quot;, user=&quot;postgres&quot;, password=&quot;Kaliakakya&quot;, host=&quot;127.0.0.1&quot;, port=&quot;5432&quot;)
print(&quot;Database opened successfully&quot;)

cur = con.cursor()
cur.execute(&quot;SELECT admission, name, age, course, department from STUDENT&quot;)
rows = cur.fetchall()

for row in rows:
 print(&quot;ADMISSION =&quot;, row[0])
 print(&quot;NAME =&quot;, row[1])
 print(&quot;AGE =&quot;, row[2])
 print(&quot;COURSE =&quot;, row[3])
 print(&quot;DEPARTMENT =&quot;, row[4], &quot;\n&quot;)

print(&quot;Operation done successfully&quot;)
con.close()
</code></pre>
Output
<pre><code class="hljs">Database opened successfully
ADMISSION = 3420
NAME = John
AGE = 18
COURSE = Computer Science
DEPARTMENT = ICT

ADMISSION = 3419
NAME = Abel
AGE = 17
COURSE = Computer Science
DEPARTMENT = ICT

ADMISSION = 3421
NAME = Joel
AGE = 17
COURSE = Computer Science
DEPARTMENT = ICT

ADMISSION = 3422
NAME = Antony
AGE = 19
COURSE = Electrical Engineering
DEPARTMENT = Engineering

ADMISSION = 3423
NAME = Alice
AGE = 18
COURSE = Information Technology
DEPARTMENT = ICT

Operation done successfully
</code></pre>
Here we have retrieved data from the database by specifying the table and names of the columns that we need to retrieve from the database table. This data is returned to us as list of tuples, with the &quot;top level&quot; list being the rows of data. Then each row is a tuple of the column data. If no rows are returned for the query then an empty list is returned by <code>fetchall()</code>.
<h2 id="updatingtables">Updating Tables</h2>
We can update or modify the details of a record that has already been inserted into a database table. First, we have to establish a connection to the database using the <code>connect()</code> method. Next, we call the <code>cursor()</code> function to create a cursor object. Finally, we run the <code>execute()</code> method to execute the <code>UPDATE</code> statement with input values.
For example:
<pre><code class="hljs">import psycopg2

con = psycopg2.connect(database=&quot;postgres&quot;, user=&quot;postgres&quot;, password=&quot;Kaliakakya&quot;, host=&quot;127.0.0.1&quot;, port=&quot;5432&quot;)
print(&quot;Database opened successfully&quot;)

cur = con.cursor()

cur.execute(&quot;UPDATE STUDENT set AGE = 20 where ADMISSION = 3420&quot;)
con.commit()
print(&quot;Total updated rows:&quot;, cur.rowcount)

cur.execute(&quot;SELECT admission, age, name, course, department from STUDENT&quot;)
rows = cur.fetchall()
for row in rows:
 print(&quot;ADMISSION =&quot;, row[0])
 print(&quot;NAME =&quot;, row[1])
 print(&quot;AGE =&quot;, row[2])
 print(&quot;COURSE =&quot;, row[2])
 print(&quot;DEPARTMENT =&quot;, row[3], &quot;\n&quot;)

print(&quot;Operation done successfully&quot;)
con.close()
</code></pre>
Output
<pre><code class="hljs">Database opened successfully
Total updated rows: 1
ADMISSION = 3419
NAME = 17
AGE = Abel
COURSE = Abel
DEPARTMENT = Computer Science

ADMISSION = 3421
NAME = 17
AGE = Joel
COURSE = Joel
DEPARTMENT = Computer Science

ADMISSION = 3422
NAME = 19
AGE = Antony
COURSE = Antony
DEPARTMENT = Electrical Engineering

ADMISSION = 3423
NAME = 18
AGE = Alice
COURSE = Alice
DEPARTMENT = Information Technology

ADMISSION = 3420
NAME = 20
AGE = John
COURSE = John
DEPARTMENT = Computer Science

Operation done successfully
</code></pre>
In the above example, we have updated the value of column <code>AGE</code> for all rows where the <code>ADMISSION</code> is 3420. After executing the update we then retrieve this data to verify that the appropriate rows/columns have been updated.
<h2 id="deletingrows">Deleting Rows</h2>
To delete a record from a Postgres database table, we should first establish a connection to the database server. Secondly, a cursor object should be created by calling the <code>cursor()</code> function. We then run the <code>DELETE</code> statement to perform the deletion.
For example:
<pre><code class="hljs">import psycopg2

con = psycopg2.connect(database=&quot;postgres&quot;, user=&quot;postgres&quot;, password=&quot;Kaliakakya&quot;, host=&quot;127.0.0.1&quot;, port=&quot;5432&quot;)
print(&quot;Database opened successfully&quot;)

cur = con.cursor()

cur.execute(&quot;DELETE from STUDENT where ADMISSION=3420;&quot;)
con.commit()
print(&quot;Total deleted rows:&quot;, cur.rowcount)

cur.execute(&quot;SELECT admission, name, age, course, department from STUDENT&quot;)
rows = cur.fetchall()
for row in rows:
 print(&quot;ADMISSION =&quot;, row[0])
 print(&quot;NAME =&quot;, row[1])
 print(&quot;AGE =&quot;, row[2])
 print(&quot;COURSE =&quot;, row[3])
 print(&quot;DEPARTMENT =&quot;, row[4], &quot;\n&quot;)

print(&quot;Deletion successful&quot;)
con.close()
</code></pre>
Output
<pre><code class="hljs">Database opened successfully
Total deleted rows: 1
ADMISSION = 3419
NAME = Abel
AGE = 17
COURSE = Computer Science
DEPARTMENT = ICT

ADMISSION = 3421
NAME = Joel
AGE = 17
COURSE = Computer Science
DEPARTMENT = ICT

ADMISSION = 3422
NAME = Antony
AGE = 19
COURSE = Electrical Engineering
DEPARTMENT = Engineering

ADMISSION = 3423
NAME = Alice
AGE = 18
COURSE = Information Technology
DEPARTMENT = ICT

Deletion successful
</code></pre>
In this example we have deleted all records where the admission number of the student is 3420, which in this case is only one row. After retrieving the data using <code>SELECT</code>, we can see that this record is not part of the above output, confirming that it has been deleted from the database.
<h2 id="conclusion">Conclusion</h2>
With Python, there are various ways we can access a PostgreSQL database. There are many database drivers for Python that we can use for this purpose, but <code>psycopg</code> is the most popular one. In this article we showed how to install the module, establish a connection to your PostgreSQL database, and execute common SQL queries using Python code.

Nicholas Samuel

Working with PostgreSQL in Python

Usman Malik

Python for NLP: Parts of Speech Tagging and Named Entity Recognition

Programming reflects your way of thinking in order to describe the single steps that you took to solve a problem using a computer. Commenting your code helps explain your thought process, and helps you and others to understand later on the intention of your code. This allows you to more easily find errors, to fix them, to improve the code later on, and to reuse it in other applications as well.
Commenting is important to all kinds of projects, no matter whether they are - small, medium, or rather large. It is an essential part of your workflow, and is seen as good practice for developers. Without comments, things can get confusing, real fast. In this article we will explain the various methods of commenting Python supports, and how it can be used to automatically create documentation for your code using the so-called module-level docstrings.
<h2 id="goodvsbadcomments">Good vs Bad Comments</h2>
As important as comments are, it's still possible to write bad comments. They should always be short, straight to the point, and add informative value.
For example, this is a rather useless comment:
<pre><code class="hljs">b = 56 # assigning to b a value of 56
</code></pre>
The next example shows a more helpful comment, instead, and goes along with giving variables obvious names:
<pre><code class="hljs">salestax10 = 1.10 # defining a sales tax of 10%
salestax20 = 1.20 # defining a sales tax of 20%
</code></pre>
There are an infinite number of other scenarios that warrant comments. This is just one example. A good rule of thumb would be to add comments for any line of code (like a list comprehension) or section of code whose purpose isn't obvious. This is very subjective, and is actually a skill that needs to be learned.
<h2 id="typesofcomments">Types of Comments</h2>
A comment in Python starts with the hash character, <code>#</code>, and extends to the end of the physical line. A hash character within a string value is not seen as a comment, though. To be precise, a comment can be written in three ways - entirely on its own line, next to a statement of code, and as a multi-line comment block.
In the following sections I'll describe each type of comment.
<h3 id="singlelinecomments">Single-Line Comments</h3>
Such a comment starts with a hash character (<code>#</code>), and is followed by text that contains further explanations.
<pre><code class="hljs"># defining the post code
postCode = 75000
</code></pre>
You can also write a comment next to a code statement. The next example shows that:
<pre><code class="hljs"># define the general structure of the product with default values
product = {
 &quot;productId&quot;: 0, # product reference id, default: 0
 &quot;description&quot;: &quot;&quot;, # item description, default: empty
 &quot;categoryId&quot;: 0, # item category, default: 0
 &quot;price&quot;: 0.00 # price, default: 0.00
}
</code></pre>
The Style Guide for Python Code (<a rel="nofollow" target="_blank" href="https://www.python.org/dev/peps/pep-0008/#maximum-line-length">PEP8</a>) recommends less than 79 characters per line. In practice, 70 or 72 characters per line are easier to read, and thus is recommended. If your comment is approaching or exceeding this length then you will want to spread it out over multiple lines.
<h3 id="multilinecomments">Multi-Line Comments</h3>
As already mentioned above, an entire comment block is also understood by Python. These comments serve as in-line documentation for others reading your code, and explain things in more detail, usually.
Technically Python doesn't have explicit support for multi-line comments, so the following options are considered a workaround by some, but still work for the purpose of multi-line comments.
Version 1 combines single-line comments as follows:
<pre><code class="hljs"># LinuxThingy version 1.6.5
#
# Parameters:
#
# -t (--text): show the text interface
# -h (--help): display this help
</code></pre>
Version 2 is simpler than version 1. It's originally intended to be used for creating documentation (see more about this below), but it can also be used for multi-line comments.
<pre><code class="hljs">&quot;&quot;&quot;
LinuxThingy version 1.6.5

Parameters:

-t (--text): show the text interface
-h (--help): display this help
&quot;&quot;&quot;
</code></pre>
Note that the latter version needs to be enclosed in special quotation marks (<code>&quot;&quot;&quot;</code>) to work, and not hash characters.
<h2 id="commonpractice">Common Practice</h2>
It is quite common to start a Python file with a few lines of comments. These lines state information regarding the project, the purpose of the file, the programmer who developed it or has worked on it, and the software license that is used for the code.
This snippet is taken from one of the examples I use for training purposes. The comment starts with the description, and is followed by the copyright notice with my name, and the year of publication of the code. Below you will see that the code is licensed under GNU Public License (<a rel="nofollow" target="_blank" href="https://www.gnu.org/licenses/gpl.html">GPL</a>). In order to contact me my email address is added there too.
<pre><code class="hljs"># -----------------------------------------------------------
# demonstrates how to write ms excel files using python-openpyxl
#
# (C) 2015 Frank Hofmann, Berlin, Germany
# Released under GNU Public License (GPL)
# email frank.hofmann@efho.de
# -----------------------------------------------------------
</code></pre>
<h2 id="docstringcomments">Docstring Comments</h2>
Python has a built-in concept called <a target="_blank" href="/python-docstrings/">docstrings</a>, which is a great way to associate documentation you've written with Python modules, functions, classes, and methods. A docstring is added as a comment right below the function, module, or object head, and describes what the function, module, or object does. It is expected to follow these rules:
<ul>
<li>
A docstring is either a single line, or a multi-line comment. In the latter case, the first line is a short description, and after the first line an empty line follows.
</li>
<li>
Begin the docstring with a capital letter, and end it with a period.
</li>
</ul>
This is a basic example of what it looks like:
<pre><code class="hljs">def add(value1, value2):
 &quot;&quot;&quot;Calculate the sum of value1 and value2.&quot;&quot;&quot;
 return value1 + value2
</code></pre>
In the Python interactive help system, the docstring is then made available via the <code>__doc__</code> attribute.
<pre><code class="hljs">&gt;&gt;&gt; print add.__doc__
Calculate the sum of value1 and value2.
</code></pre>
There is a number of tools that auto-generate documentation from docstrings, such as <a rel="nofollow" target="_blank" href="http://www.doxygen.nl/">Doxygen</a>, <a rel="nofollow" target="_blank" href="https://docs.python.org/3/library/pydoc.html">PyDoc</a>, <a rel="nofollow" target="_blank" href="https://pdoc3.github.io/pdoc/">pdoc</a>, and the <a rel="nofollow" target="_blank" href="http://www.sphinx-doc.org/en/master/usage/extensions/autodoc.html">autodoc</a> extension for Sphinx. We will explain to you how to work with them in a follow-up article.
<h2 id="conclusion">Conclusion</h2>
Writing proper comments in your Python code is not that complicated, and you just need the power of endurance. It helps all of us that are trying to understand your code, including yourself for when you revisit your code at a later date. We hope that the advice we have given you here makes it easier for you to create better comments and documentation in your code.
<h2 id="acknowledgements">Acknowledgements</h2>
The author would like to thank Zoleka Hofmann for her critical comments while preparing this article.

Frank Hofmann

Commenting Python Code

This article applies to sites created with the Spring Boot framework, using Apache Maven as the build tool. In order to demonstrate how profiles work, we'll visit an example using Google Analytics and Google Tag Manager for tracking site metrics. I use this method for my website, <a rel="nofollow" target="_blank" href="https://initialcommit.com">Initial Commit</a>, which is built using Spring Boot, the Thymeleaf template engine, and is hosted on AWS Elastic Beanstalk.
<h2 id="whatarespringbootprofiles">What are Spring Boot Profiles?</h2>
One of the core design principles behind Spring Boot is that it encourages convention over configuration. This means that the vast majority of app configurations use sensible default values that can be overridden when necessary, but in general a Spring Boot app will work out of the box with no custom configuration required.
However, usually some customization is necessary and oftentimes we need environment specific customization. This is where profiles come in handy. A profile in Spring Boot can be thought of as a context that defines a specific set of app settings, variables, and behaviors. Each time the app is built, the developer can specify which profile to use. If no profile is specified, the default will be used.
In this article, we will create a DEV profile and PROD profile to enable environment-specific configuration properties.
We can easily define the profiles by adding the following XML to the project's <code>pom.xml</code> file:
<pre><code class="hljs"> &lt;profiles&gt;
 &lt;profile&gt;
 &lt;id&gt;dev&lt;/id&gt;
 &lt;properties&gt;
 &lt;activatedProperties&gt;dev&lt;/activatedProperties&gt;
 &lt;/properties&gt;
 &lt;activation&gt;
 &lt;activeByDefault&gt;true&lt;/activeByDefault&gt;
 &lt;/activation&gt;
 &lt;/profile&gt;
 &lt;profile&gt;
 &lt;id&gt;prod&lt;/id&gt;
 &lt;properties&gt;
 &lt;activatedProperties&gt;prod&lt;/activatedProperties&gt;
 &lt;/properties&gt;
 &lt;/profile&gt;
 &lt;/profiles&gt;
</code></pre>
Note the <code>&lt;activeByDefault&gt;true&lt;/activeByDefault&gt;</code> tag, which means that the development profile will be used by default assuming no profile is specified at build time.
Profiles work in conjunction with Spring Boot properties files. By default, Spring Boot parses a file called <code>application.properties</code> – located in the <code>src/main/resources</code> directory – to identify configuration information.
Our first task will be to add a parameter in that file which will tell Spring to use a different environment-specific property file corresponding to the active profile (i.e. the profile that the app is currently being run with). We can do this by adding the following to the <code>application.properties</code> file:
<pre><code class="hljs">spring.profiles.active=@activatedProperties@
</code></pre>
Now we need to create the two new environment-specific property files (in the same path as the existing <code>application.properties</code> file), one to be used by the DEV profile and one to be used by the PROD profile. These files need to be named the following:
<ul>
<li><code>application-dev.properties</code></li>
<li><code>application-prod.properties</code></li>
</ul>
Within each of these files, properties can be defined that will only be applied when the corresponding profile is active.
In order to make this concept clearer, let's consider a real-world example involving Google Analytics and Google Tag Manager configuration on a Spring Boot site, which I'll go over in detail in the next few sections.
<h2 id="overviewofgoogleanalyticsandgoogletagmanager">Overview of Google Analytics and Google Tag Manager</h2>
If you are a web developer with an active site, it is a good bet that you use the Google platform for your analytics, event tracking, conversion tracking, and search engine ranking statistics.
The following free Google tools provide these services:
<ol>
<li>Google Analytics</li>
<li>Google Tag Manager</li>
<li>Google Search Console</li>
</ol>
Google Analytics links up to your domain and tracks a wide breadth of statistics including page views, session information, audience location, and event triggers in historical and real-time contexts.
Google Tag Manager integrates with Google Analytics and allows developers to define the events that get tracked by Google Analytics. This is done by defining Tag Manager listeners that link up to specific HTML elements on your website, which wait for the specified events (like a click or scroll) to occur. When a site user executes the event, a call gets made to Google Analytics, which logs the event.
Google Search Console provides information about how Google crawls your site, how many sites link back to yours, and where your site ranks based on search keywords.
If you've used these tools before, you'll know that in order to link your website to your Google Analytics account, Google provides a Tracking ID in the following format:
<pre><code class="hljs">UA-123456789-1
</code></pre>
This tracking ID gets embedded into your site via an HTML code snippet provided by Google:
<pre><code class="hljs">&lt;!-- Global site tag (gtag.js) - Google Analytics --&gt;
&lt;script async src=&quot;https://www.googletagmanager.com/gtag/js?id=UA-123456789-1&quot;&gt;&lt;/script&gt;
&lt;script&gt;
 window.dataLayer = window.dataLayer || [];
 function gtag(){dataLayer.push(arguments);}
 gtag(&#x27;js&#x27;, new Date());

 gtag(&#x27;config&#x27;, ‘UA-123456789-1&#x27;);
&lt;/script&gt;
</code></pre>
Similarly, Google Tag Manager provides a GTM ID in the following format:
<pre><code class="hljs">GTM-ABCDEF1
</code></pre>
This also needs to be embedded into your site via an HTML code snippet:
<pre><code class="hljs">&lt;!-- Google Tag Manager --&gt;
&lt;script&gt;(function(w,d,s,l,i){w[l]=w[l]||[];w[l].push({&#x27;gtm.start&#x27;:
new Date().getTime(),event:&#x27;gtm.js&#x27;});var f=d.getElementsByTagName(s)[0],
j=d.createElement(s),dl=l!=&#x27;dataLayer&#x27;?&#x27;&amp;l=&#x27;+l:&#x27;&#x27;;j.async=true;j.src=
&#x27;https://www.googletagmanager.com/gtm.js?id=&#x27;+i+dl;f.parentNode.insertBefore(j,f);
})(window,document,&#x27;script&#x27;,&#x27;dataLayer&#x27;,&#x27;GTM-ABCDEF1&#x27;);&lt;/script&gt;
&lt;!-- End Google Tag Manager --&gt;

&lt;!-- Google Tag Manager (noscript) --&gt;
&lt;noscript&gt;&lt;iframe src=&quot;https://www.googletagmanager.com/ns.html?id=GTM-ABCDEF1&quot;
height=&quot;0&quot; width=&quot;0&quot; style=&quot;display:none;visibility:hidden&quot;&gt;&lt;/iframe&gt;&lt;/noscript&gt;
&lt;!-- End Google Tag Manager (noscript) --&gt;
</code></pre>
<h2 id="configuringtrackingidswithprofiles">Configuring Tracking IDs with Profiles</h2>
Now, this is all well and good – users who interact with the site will trigger data to be logged into the linked Google Analytics account. However, since the tracking IDs are hard-coded into the HTML pages, data will be tracked even when developers and testers load up these pages in development and test versions of the site. This will skew the data and inflate the actual site statistics.
In order to solve this problem, we can set up dummy values for the tracking IDs in the development profile so that no data is logged to Google when the site pages are accessed in the lower environments.
The DEV profile will define dummy values for the Google Analytics and Tag Manager tracking IDs, and the PROD profile will use the real values. We will then replace the hard-coded values in the HTML templates with the dynamic property value.
In the DEV properties file, <code>application-dev.properties</code>, we can add the dummy values for the Google Analytics and Tag Manager tracking IDs like this:
<pre><code class="hljs">googleanalyticsid=UA-XXXXXXXXXX-1
googletagmanagerid=GTM-XXXXXX1
</code></pre>
In the PROD properties file, <code>application-prod.properties</code>, we can add the actual values for the Google Analytics and Tag Manager tracking IDs:
<pre><code class="hljs">googleanalyticsid=UA-123456789-1
googletagmanagerid=GTM-ABCDEF1
</code></pre>
The final step is to replace the hard coded reference to the tracking IDs in the HTML templates. Using the <a rel="nofollow" target="_blank" href="https://www.thymeleaf.org/">Thymeleaf</a> template engine, this can be done by replacing the hard-coded Google Analytics tracking ID with:
<pre><code class="hljs">${@environment.getProperty(&#x27;googleanalyticsid&#x27;)}
</code></pre>
and the Google Tag Manager tracking ID with:
<pre><code class="hljs">${@environment.getProperty(&#x27;googletagmanagerid&#x27;)}
</code></pre>
The end result is that the code snippets provided by Google now look like this (note that due to nested quotes, double square brackets are added around the variable):
<pre><code class="hljs"> &lt;!-- Global site tag (gtag.js) - Google Analytics --&gt;
 &lt;script async th:src=&quot;&#x27;https://www.googletagmanager.com/gtag/js?id=&#x27; + ${@environment.getProperty(&#x27;googleanalyticsid&#x27;)}&quot;&gt;&lt;/script&gt;
 &lt;script&gt;
 window.dataLayer = window.dataLayer || [];
 function gtag(){dataLayer.push(arguments);}
 gtag(&#x27;js&#x27;, new Date());

 gtag(&#x27;config&#x27;, &quot;[[${@environment.getProperty(&#x27;googleanalyticsid&#x27;)}]]&quot;);
 &lt;/script&gt;

 &lt;!-- Google Tag Manager --&gt;
 &lt;script&gt;(function(w,d,s,l,i){w[l]=w[l]||[];w[l].push({&#x27;gtm.start&#x27;:
 new Date().getTime(),event:&#x27;gtm.js&#x27;});var f=d.getElementsByTagName(s)[0],
 j=d.createElement(s),dl=l!=&#x27;dataLayer&#x27;?&#x27;&amp;l=&#x27;+l:&#x27;&#x27;;j.async=true;j.src=
 &#x27;https://www.googletagmanager.com/gtm.js?id=&#x27;+i+dl;f.parentNode.insertBefore(j,f);
 })(window,document,&#x27;script&#x27;,&#x27;dataLayer&#x27;,&quot;[[${@environment.getProperty(&#x27;googletagmanagerid&#x27;)}]]&quot;);&lt;/script&gt;
 &lt;!-- End Google Tag Manager --&gt;

 &lt;!-- Google Tag Manager (noscript) --&gt;
 &lt;noscript&gt;&lt;iframe th:src=&quot;&#x27;https://www.googletagmanager.com/ns.html?id=&#x27; + ${@environment.getProperty(&#x27;googletagmanagerid&#x27;)}&quot;
 height=&quot;0&quot; width=&quot;0&quot; style=&quot;display:none;visibility:hidden&quot;&gt;&lt;/iframe&gt;&lt;/noscript&gt;
 &lt;!-- End Google Tag Manager (noscript) --&gt;
</code></pre>
That's it! Now whenever the application is built and run without specifying the profile – for example from within an IDE like Spring Tool Suite, Eclipse, or IntelliJ – the DEV profile will be chosen by default and dummy values will be substituted for the Google tracking IDs. This will prevent any page loads and triggered events from logging data to the Google platform.
<h2 id="specifyingtheprofileatbuildtime">Specifying the Profile at Build Time</h2>
When building the application for production, we need to specify the PROD profile is to be used so that the real tracking ID values are used. Here is how this is done using Maven as the build tool:
<pre><code class="hljs">$ mvn -Pprod clean install
</code></pre>
The key to this command is the <code>-P</code> flag, which is used to specify the profile to use for the build.
If we want to set the profile after the code is built, we can use a Java VM argument at application launch. This is done as follows:
<pre><code class="hljs">$ java –jar -Dspring.profiles.active=prod app.jar
</code></pre>
Alternatively, the profile can be directly specified in the <code>application.properties</code> file by adding the line:
<pre><code class="hljs">spring.profiles.active=prod
</code></pre>
In each case, we specify <code>prod</code> as the active profile, which causes the <code>application-prod.properties</code> file to be chosen for configuration purposes. Since this file contains the real values for the tracking IDs, those will be inserted into the templates in the production build and user events will be successfully tracked on the Google platform.
<h2 id="abouttheauthor">About the Author</h2>
This article was written by Jacob Stopak, a software consultant and developer with passion for helping others improve their lives through code. Jacob is the creator of <a rel="nofollow" target="_blank" href="https://initialcommit.com">Initial Commit</a> - a site dedicated to helping curious developers learn how their favorite programs are coded. Its featured project helps people <a rel="nofollow" target="_blank" href="https://initialcommit.com/blog/Learn-Git-Guidebook-For-Developers-Chapter-1">learn Git</a> at the code level.

Jacob Stopak

Spring Boot Profiles for DEV and PROD Environments

<h2 id="introduction">Introduction</h2>
Graphs are one of the most useful data structures. They can be used to model practically any setting - object relations and networks being the most common ones. An image can be represented as a grid-like graph of pixels, and language can be represented as a graph of words. Graphs are used in various fields, from cartography to social psychology even, and of course they are widely used in Computer Science.
<ul>
<li><a target="_blank" href="/graph-theory-and-graph-related-algorithms-theory-and-implementation">Graph Theory and Graph-Related Algorithm's Theory and Implementation</a>
<ul>
<li><a target="_blank" href="/graphs-in-python-representing-graphs-in-code/">Representing Graphs in Code</a></li>
<li><a target="_blank" href="/depth-first-search-dfs-in-python-theory-and-implementation/">Depth-First Search (DFS)</a></li>
<li><a target="_blank" href="/graphs-in-python-breadth-first-search-bfs-algorithm/">Breadth-First Search (BFS)</a></li>
<li><a target="_blank" href="/dijkstras-algorithm-in-python/">Dijkstra's Algorithm</a></li>
<li>A* Search</li>
<li><a target="_blank" href="/boruvkas-algorithm-in-python-theory-and-implementation">Minimum Spanning Trees - Borůvka's Algorithm</a></li>
<li><a target="_blank" href="/graphs-in-python-minimum-spanning-trees-kruskals-algorithm">Minimum Spanning Trees - Kruskal's Algorithm</a></li>
<li><a target="_blank" href="/graphs-in-python-minimum-spanning-trees-prims-algorithm">Minimum Spanning Trees - Prim's Algorithm</a></li>
</ul>
</li>
</ul>
A path search problem is a computational problem where you have to find a path from point A to point B. In our case, we'll be mapping search problems to appropriate graphs, where the nodes represent all the possible states we can end up in and the edges representing all the possible paths that we have at our disposal.
So the next logical question would be:
<blockquote>
How do we convert a problem into a search problem?
</blockquote>
<h2 id="whatisa">What is A*?</h2>
Let's say that you have to get through an enormous maze. This maze is so big that it would take hours to find the goal manually. Additionally, once you finish the maze &quot;by foot&quot;, you're supposed to finish another one.
To make things significantly easier and less time consuming, we'll boil the maze down to a search problem, and come up with a solution that can be applied to any additional maze that we may encounter - as long as it follows the same rules/structure.
Any time we want to convert any kind of problem into a search problem, we have to define six things:
<ol>
<li>A set of all states we might end up in</li>
<li>The start and finish state</li>
<li>A finish check (a way to check if we're at the finished state)</li>
<li>A set of possible actions (in this case, different directions of movement)</li>
<li>A traversal function (a function that will tell us where we'll end up if we go a certain direction)</li>
<li>A set of movement costs from state-to-state (which correspond to edges in the graph)</li>
</ol>
The maze problem can be solved by mapping the intersections to appropriate nodes (red dots), and the possible directions we can go to appropriate graph edges (blue lines).
Naturally, we define the start and finish states as the intersections where we enter the maze (node A), and where we want to exit the maze (node B).
<img src="https://s3.amazonaws.com/stackabuse/media/basic-ai-concepts-a-search-algorithm-1.png" alt="Maze with state nodes">
Now that we have a finished graph, we can discuss algorithms for finding a path from state A to state B. In simple cases (like this one), where the generated graph consists of a small number of nodes and edges, <a rel="nofollow" target="_blank" href="https://stackabuse.com/courses/graphs-in-python-theory-and-implementation/lessons/breadth-first-search-bfs-algorithm/">BFS</a>, <a target="_blank" rel="https://stackabuse.com/depth-first-search-dfs-in-python-theory-and-implementation/">DFS</a> and <a target="_blank" href="https://stackabuse.com/dijkstras-algorithm-in-python/">Dijkstra</a> would suffice.
However, in a real-life scenario, because we are dealing with problems of enormous combinatorial complexity, we know we will have to deal with an enormous amount of nodes and edges. For example, there are many states a Rubik's cube can be in, which is why solving it is so difficult. Therefore, we have to use an algorithm that is, in a sense, guided. That is where an informed search algorithm arises, A*.
Informed Search signifies that the algorithm has extra information, to begin with. For example, an uninformed search problem algorithm would be finding a path from home to work completely blind.
On the flip-side, an informed search problem algorithm would be finding a path from home to work with the aid of your sight (seeing what path brings you closer to your destination) or a map (knowing exactly how far away every single point is from your destination).
A* only performs a step if it seems promising and reasonable, according to its functions, unlike other graph-traversal algorithms. It runs towards the goal and doesn't consider any non-optimal steps if it doesn't have to consider them.
This makes A* very useful for artificially intelligent systems - especially in Machine Learning and game development since these systems replicate real-world scenarios.
If you'd like to read more about <a target="_blank" href="/graph-data-structure-interview-questions/">graph-traversal algorithms</a>, their applications and differences, we've got them covered!
<h2 id="basicconceptsofa">Basic Concepts of A*</h2>
A* is based on using <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Heuristic_(computer_science)">heuristic</a> methods to achieve optimality and completeness, and is a variant of the best-first algorithm.
When a search algorithm has the property of optimality, it means it is guaranteed to find the best possible solution, in our case the shortest path to the finish state. When a search algorithm has the property of completeness, it means that if a solution to a given problem exists, the algorithm is guaranteed to find it.
Each time A* enters a state, it calculates the cost, <code>f(n)</code> (n being the neighboring node), to travel to all of the neighboring nodes, and then enters the node with the lowest value of <code>f(n)</code>.
These values are calculated with the following formula:
$$ 
\mathcal f(n) = \mathcal g(n) + \mathcal h(n) 
$$
<code>g(n)</code> being the value of the shortest path from the start node to node n, and <code>h(n)</code> being a heuristic approximation of the node's value.
For us to be able to reconstruct any path, we need to mark every node with the relative that has the optimal <code>f(n)</code> value. This also means that if we revisit certain nodes, we'll have to update their most optimal relatives as well. More on that later.
The efficiency of A* is highly dependent on the heuristic value <code>h(n)</code>, and depending on the type of problem, we may need to use a different heuristic function for it to find the optimal solution.
Construction of such functions is no easy task and is one of the fundamental problems of AI. The two fundamental properties a heuristic function can have are admissibility and consistency.
<h2 id="admissibilityandconsistency">Admissibility and Consistency</h2>
A given heuristic function <code>h(n)</code> is admissible if it never overestimates the real distance between n and the goal node.
Therefore, for every node n the following formula applies:
$$ 
h(n)\leq h^*(n) 
$$
<code>h*(n)</code> being the real distance between n and the goal node. However, if the function does overestimate the real distance, but never by more than d, we can safely say that the solution that the function produces is of accuracy d (i.e. it doesn't overestimate the shortest path from start to finish by more than d).
A given heuristic function <code>h(n)</code> is consistent if the estimate is always less than or equal to the estimated distance between the goal n and any given neighbor, plus the estimated cost of reaching that neighbor:
$$ 
c(n,m)+h(m)\geq h(n) 
$$
<code>c(n,m)</code> being the distance between nodes <code>n</code> and <code>m</code>. Additionally, if <code>h(n)</code> is consistent, then we know the optimal path to any node that has been already inspected. This means that this function is optimal.
Theorem: If a heuristic function is consistent, then it is also admissible.
<h2 id="proofbycompleteinduction">Proof by Complete Induction</h2>
The induction parameter <code>N</code> will be the number of nodes between node <code>n</code> and the finish node <code>s</code> on the shortest path between the two.
Base: N=0
If there are no nodes between <code>n</code> and <code>s</code>, and because we know that <code>h(n)</code> is consistent, the following equation is valid:
$$ 
c(n,s)+h(s)\geq h(n) 
$$
Knowing <code>h*(n)=c(n,s)</code> and <code>h(s)=0</code> we can safely deduce that:
$$ 
h^*(n)\geq h(n) 
$$
Induction hypothesis: N &lt; k
We hypothesize that the given rule is true for every <code>N &lt; k</code>.
Induction step:
In the case of <code>N = k</code> nodes on the shortest path from <code>n</code> to <code>s</code>, we inspect the first successor (node <code>m</code>) of the finish node <code>n</code>. Because we know that there is a path from <code>m</code> to <code>n</code>, and we know this path contains <code>k-1</code> nodes, the following equation is valid:
$$ 
ℎ^*(𝑛) = 𝑐(𝑛, 𝑚) + ℎ^*(𝑚) ≥ 𝑐(𝑛, 𝑚) + ℎ(𝑚) ≥ ℎ(𝑛) 
$$
Q.E.D.
<h2 id="implementation">Implementation</h2>
This is a direct implementation of A* on a graph structure. The heuristic function is defined as 1 for all nodes for the sake of simplicity and brevity.
The graph is represented with an adjacency list, where the keys represent graph nodes, and the values contain a list of edges with the corresponding neighboring nodes.
Here you'll find the A* algorithm implemented in Python:
<pre><code class="hljs">from collections import deque

class Graph:
 # example of adjacency list (or rather map)
 # adjacency_list = {
 # &#x27;A&#x27;: [(&#x27;B&#x27;, 1), (&#x27;C&#x27;, 3), (&#x27;D&#x27;, 7)],
 # &#x27;B&#x27;: [(&#x27;D&#x27;, 5)],
 # &#x27;C&#x27;: [(&#x27;D&#x27;, 12)]
 # }

 def __init__(self, adjacency_list):
 self.adjacency_list = adjacency_list

 def get_neighbors(self, v):
 return self.adjacency_list[v]

 # heuristic function with equal values for all nodes
 def h(self, n):
 H = {
 &#x27;A&#x27;: 1,
 &#x27;B&#x27;: 1,
 &#x27;C&#x27;: 1,
 &#x27;D&#x27;: 1
 }

 return H[n]

 def a_star_algorithm(self, start_node, stop_node):
 # open_list is a list of nodes which have been visited, but who&#x27;s neighbors
 # haven&#x27;t all been inspected, starts off with the start node
 # closed_list is a list of nodes which have been visited
 # and who&#x27;s neighbors have been inspected
 open_list = set([start_node])
 closed_list = set([])

 # g contains current distances from start_node to all other nodes
 # the default value (if it&#x27;s not found in the map) is +infinity
 g = {}

 g[start_node] = 0

 # parents contains an adjacency map of all nodes
 parents = {}
 parents[start_node] = start_node

 while len(open_list) &gt; 0:
 n = None

 # find a node with the lowest value of f() - evaluation function
 for v in open_list:
 if n == None or g[v] + self.h(v) &lt; g[n] + self.h(n):
 n = v;

 if n == None:
 print(&#x27;Path does not exist!&#x27;)
 return None

 # if the current node is the stop_node
 # then we begin reconstructing the path from it to the start_node
 if n == stop_node:
 reconst_path = []

 while parents[n] != n:
 reconst_path.append(n)
 n = parents[n]

 reconst_path.append(start_node)

 reconst_path.reverse()

 print(&#x27;Path found: {}&#x27;.format(reconst_path))
 return reconst_path

 # for all neighbors of the current node do
 for (m, weight) in self.get_neighbors(n):
 # if the current node isn&#x27;t in both open_list and closed_list
 # add it to open_list and note n as it&#x27;s parent
 if m not in open_list and m not in closed_list:
 open_list.add(m)
 parents[m] = n
 g[m] = g[n] + weight

 # otherwise, check if it&#x27;s quicker to first visit n, then m
 # and if it is, update parent data and g data
 # and if the node was in the closed_list, move it to open_list
 else:
 if g[m] &gt; g[n] + weight:
 g[m] = g[n] + weight
 parents[m] = n

 if m in closed_list:
 closed_list.remove(m)
 open_list.add(m)

 # remove n from the open_list, and add it to closed_list
 # because all of his neighbors were inspected
 open_list.remove(n)
 closed_list.add(n)

 print(&#x27;Path does not exist!&#x27;)
 return None
</code></pre>
Let's look at an example with the following weighted graph:
<img src="https://s3.amazonaws.com/stackabuse/media/basic-ai-concepts-a-search-algorithm-2.png" alt="Maze example 2">
We run the code as so:
<pre><code class="hljs">adjacency_list = {
 &#x27;A&#x27;: [(&#x27;B&#x27;, 1), (&#x27;C&#x27;, 3), (&#x27;D&#x27;, 7)],
 &#x27;B&#x27;: [(&#x27;D&#x27;, 5)],
 &#x27;C&#x27;: [(&#x27;D&#x27;, 12)]
}
graph1 = Graph(adjacency_list)
graph1.a_star_algorithm(&#x27;A&#x27;, &#x27;D&#x27;)
</code></pre>
And the output would look like:
<pre><code class="hljs">Path found: [&#x27;A&#x27;, &#x27;B&#x27;, &#x27;D&#x27;]
[&#x27;A&#x27;, &#x27;B&#x27;, &#x27;D&#x27;]
</code></pre>
Thus, the optimal path from <code>A</code> to <code>D</code>, found using A*, is <code>A</code>-&gt;<code>B</code>-&gt;<code>D</code>.
<h2 id="conclusion">Conclusion</h2>
A* is a very powerful algorithm with almost unlimited potential. However, it is only as good as its heuristic function, which can be highly variable considering the nature of a problem.
It has found applications in many software systems, from Machine Learning and Search Optimization to game development where NPC characters navigate through complex terrain and obstacles to reach the player.

Vladimir Batoćanin

Graphs in Python: A* Search Algorithm

Python for NLP: Vocabulary and Phrase Matching with SpaCy

Scott Robinson

Vasyl Lagutin

Reading a File Line by Line in Node.js

<h2 id="introduction">Introduction</h2>
A Finite State Machine is a model of computation, i.e. a conceptual tool to design systems. It processes a sequence of inputs that changes the state of the system.
When all the input is processed, we observe the system's final state to determine whether the input sequence was accepted or not.
<h2 id="finitestatemachinecomponents">Finite State Machine Components</h2>
<a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Finite-state_machine">Finite State Machines</a> are comprised of these components:
<ul>
<li>Set of Known States: as the name implies, there must be a finite amount of states our system can be in. Only one state can be active at a time. States are usually drawn with circles:</li>
</ul>
<img src="https://s3.amazonaws.com/stackabuse/media/theory-of-computation-finite-state-machines-1.jpg" alt="State">
<ul>
<li>Initial State: the starting point of our system. Initial states are usually drawn with an arrow being pointed to them:</li>
</ul>
<img src="https://s3.amazonaws.com/stackabuse/media/theory-of-computation-finite-state-machines-2.jpg" alt="Initial State">
<ul>
<li>Set of Accepting States: a subset of known states that indicates whether the input we processed is valid or not. Accepting states are usually drawn as a double circle:</li>
</ul>
<img src="https://s3.amazonaws.com/stackabuse/media/theory-of-computation-finite-state-machines-3.jpg" alt="Accepting State">
<ul>
<li>Alphabet: also referred to as Language, is the set of all valid inputs.</li>
<li>Transitions: rules dictating how the machine moves from one state to another. These are usually drawn as two states connected by a line:</li>
</ul>
<img src="https://s3.amazonaws.com/stackabuse/media/theory-of-computation-finite-state-machines-4.jpg" alt="Transition">
<h2 id="binaryparserdemonstration">Binary Parser Demonstration</h2>
Let's create a Finite State Machine that parses a binary sequence where every time we encounter a 1, we immediately encounter a 0. For example, 1010 is a valid input sequence but 1110 and 1010100 are not.
We can create a Finite State Machine like this:
<img src="https://s3.amazonaws.com/stackabuse/media/theory-of-computation-finite-state-machines-5.jpg" alt="Binary Parser">
Our Finite State Machine has 3 states: State 1, State 2 and Error.
Here, we have a few possible situations:
<ul>
<li>If we're at State 1 and encounter a 1, we move to State 2.</li>
<li>If we're at State 2 and encounter a 0, we move back to State 1.</li>
<li>If we're at State 1 and encounter a 0, we go to the Error state.</li>
<li>If we're at State 2 and encounter a 1, we go to the Error state.</li>
</ul>
As you would observe, any input in the Error state keeps it there, as you are not able to transition out of the error state.
<h2 id="creatinganfsminpython">Creating an FSM in Python</h2>
Many software solutions implement Finite State Machines to manage some aspect of states. We can implement a Finite State Machine in Python and programmatically verify input for a given set of states and transitions:
<pre><code class="hljs">class Transition:
 &quot;&quot;&quot;A change from one state to a next&quot;&quot;&quot;

 def __init__(self, current_state, state_input, next_state):
 self.current_state = current_state
 self.state_input = state_input
 self.next_state = next_state

 def match(self, current_state, state_input):
 &quot;&quot;&quot;Determines if the state and the input satisfies this transition relation&quot;&quot;&quot;
 return self.current_state == current_state and self.state_input == state_input

class FSM:
 &quot;&quot;&quot;A basic model of computation&quot;&quot;&quot;

 def __init__(
 self,
 states=[],
 alphabet=[],
 accepting_states=[],
 initial_state=&#x27;&#x27;):
 self.states = states
 self.alphabet = alphabet
 self.accepting_states = accepting_states
 self.initial_state = initial_state
 self.valid_transitions = False

 def add_transitions(self, transitions=[]):
 &quot;&quot;&quot;Before we use a list of transitions, verify they only apply to our states&quot;&quot;&quot;
 for transition in transitions:
 if transition.current_state not in self.states:
 print(
 &#x27;Invalid transition. {} is not a valid state&#x27;.format(
 transition.current_state))
 return
 if transition.next_state not in self.states:
 print(&#x27;Invalid transition. {} is not a valid state&#x27;.format)
 return
 self.transitions = transitions
 self.valid_transitions = True

 def __accept(self, current_state, state_input):
 &quot;&quot;&quot;Looks to see if the input for the given state matches a transition rule&quot;&quot;&quot;
 # If the input is valid in our alphabet
 if state_input in self.alphabet:
 for rule in self.transitions:
 if rule.match(current_state, state_input):
 return rule.next_state
 print(&#x27;No transition for state and input&#x27;)
 return None
 return None

 def accepts(self, sequence):
 &quot;&quot;&quot;Process an input stream to determine if the FSM will accept it&quot;&quot;&quot;
 # Check if we have transitions
 if not self.valid_transitions:
 print(&#x27;Cannot process sequence without valid transitions&#x27;)

 print(&#x27;Starting at {}&#x27;.format(self.initial_state))
 # When an empty sequence provided, we simply check if the initial state
 # is an accepted one
 if len(sequence) == 0:
 return self.initial_state in self.accepting_states

 # Let&#x27;s process the initial state
 current_state = self.__accept(self.initial_state, sequence[0])
 if current_state is None:
 return False

 # Continue with the rest of the sequence
 for state_input in sequence[1:]:
 print(&#x27;Current state is {}&#x27;.format(current_state))
 current_state = self.__accept(current_state, state_input)
 if current_state is None:
 return False

 print(&#x27;Ending state is {}&#x27;.format(current_state))
 # Check if the state we&#x27;ve transitioned to is an accepting state
 return current_state in self.accepting_states
</code></pre>
The <code>Transition</code> class contains a <code>match()</code> function. A quick way for us to know if the current state and input of the Finite State Machine will allow us to go to the next state defined.
The <code>FSM</code> class, after being initialized, needs the <code>add_transitions()</code> method to be called. This method validates that our transition rules are set up with valid states.
We can then use the <code>accepts()</code> method with a list of inputs to determine if our machine would be in an accepting state.
Let's test it out with the binary parser we created previously. Follow the code, run it, and take note of the results:
<pre><code class="hljs"># Set up our FSM with the required info:
# Set of states
states = [&#x27;State 1&#x27;, &#x27;State 2&#x27;, &#x27;Error&#x27;]
# Set of allowed inputs
alphabet = [1, 0]
# Set of accepted states
accepting_states = [&#x27;State 1&#x27;]
# The initial state
initial_state = &#x27;State 1&#x27;
fsm = FSM(states, alphabet, accepting_states, initial_state)

# Create the set of transitions
transition1 = Transition(&#x27;State 1&#x27;, 1, &#x27;State 2&#x27;)
transition2 = Transition(&#x27;State 2&#x27;, 0, &#x27;State 1&#x27;)
transition3 = Transition(&#x27;State 1&#x27;, 0, &#x27;Error&#x27;)
transition4 = Transition(&#x27;State 2&#x27;, 1, &#x27;Error&#x27;)
transition5 = Transition(&#x27;Error&#x27;, 1, &#x27;Error&#x27;)
transition6 = Transition(&#x27;Error&#x27;, 0, &#x27;Error&#x27;)
transitions = [
 transition1,
 transition2,
 transition3,
 transition4,
 transition5,
 transition6]
# Verify and add them to the FSM
fsm.add_transitions(transitions)

# Now that our FSM is correctly set up, we can give it input to process
# Let&#x27;s transition the FSM to a green light
should_be_accepted = fsm.accepts([1, 0, 1, 0])
print(should_be_accepted)

# Let&#x27;s transition the FSM to a red light
should_be_rejected_1 = fsm.accepts([1, 1, 1, 0])
print(should_be_rejected_1)

# Let&#x27;s transition to yellow and give it bad input
should_be_rejected_2 = fsm.accepts([1, 0, 1, 0, 1, 0, 0])
print(should_be_rejected_2)
</code></pre>
<h2 id="examples">Examples</h2>
Finite State Machines are commonly used in real world systems that extend beyond string parsing, and even beyond software systems.
<h3 id="trafficlights">Traffic lights</h3>
A simple traffic light system can be modeled with a Finite State Machine. Let's look at each core component and identify what it would be for traffics lights:
<ul>
<li>States: a traffic light generally has three states: Red, Green and Yellow.</li>
<li>Initial State: Green</li>
<li>Accepting States: in the real world traffic lights run indefinitely, so there would be no accepting states for this model.</li>
<li>Alphabet: positive integers representing seconds.</li>
<li>Transitions:</li>
<li>If we're in state Green and wait for 360 seconds (6 minutes), then we can go to state Yellow.</li>
<li>If we're in state Yellow and wait 10 seconds, then we can go to state Red.</li>
<li>If we're in state Red and wait 120 seconds, then we can go to state Green.</li>
</ul>
This Finite State Machine can be drawn as follows:
<img src="https://s3.amazonaws.com/stackabuse/media/theory-of-computation-finite-state-machines-6.jpg" alt="Traffic Lights Finite State Machine">
<h3 id="enemyai">Enemy AI</h3>
Finite State Machines allows us to map the flow of actions in a game's computer-controlled players. Let's say we were making an action game where guards patrol an area of the map. We can have a Finite State Machine with the following properties:
<ul>
<li>States: For our simplistic shooter we can have: Patrol, Attack, Reload, Take Cover, and Deceased.</li>
<li>Initial State: As it's a guard, the initial state would be Patrol.</li>
<li>Accepting States: An enemy bot can no longer accept input when it's dead, so our Deceased state will be our accepting one.</li>
<li>Alphabet: For simplicity, we can use string constants to represent a world state: Player approaches, Player runs, Full health, Low health, No health, Full ammo, and Low ammo.</li>
<li>Transitions: As this model is a bit more complex than traffic lights, we can separate the transitions by examining one state at a time:
<ul>
<li>Patrol
<ul>
<li>If a player approaches, go to the Attack state.</li>
<li>If we run out of health, go to the Deceased state.</li>
</ul>
</li>
<li>Attack
<ul>
<li>If ammo is low, go to the Reload state.</li>
<li>If health is low, go to the Take Cover state.</li>
<li>If the player escapes, go to the Patrol state.</li>
<li>If we run out of health, go to the Deceased state.</li>
</ul>
</li>
<li>Reload
<ul>
<li>If ammo is full, go to the Attack state.</li>
<li>If health is low, go to the Take Cover state.</li>
<li>If we run out of health, go to the Deceased state.</li>
</ul>
</li>
<li>Take Cover
<ul>
<li>If health is full, go to the Attack state.</li>
<li>If ammo is low, go to the Reload state.</li>
<li>If we run out of health, go to the Deceased state.</li>
</ul>
</li>
</ul>
</li>
</ul>
This Finite State Machine can be drawn as follows:
<img src="https://s3.amazonaws.com/stackabuse/media/theory-of-computation-finite-state-machines-7.jpg" alt="Guard AI">
<h2 id="limitations">Limitations</h2>
The primary benefit of Finite State Machines, their simplicity, also becomes one of their disadvantages. Systems which need an indeterminate amount of states cannot be modeled by a Finite State Machine, evidently.
Earlier we modeled a Finite State Machine that accepted the string '10' for any amount of iterations. If we had to accept a string of any number of 1s followed by the same number of 0s, we cannot create a Finite State Machine for it. A Finite State Machine does not keep track of the number of states it visited, it is only aware of the current state it is in.
This is proven by the Pumping Lemma, a proof which asserts that if a language is not regular (not so much Regular Expressions, which you may be familiar with from programming languages, but rather a classification of <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Chomsky_hierarchy">languages</a> then no Finite State Machine can be built for it. You can learn more about this proof and its implications <a rel="nofollow" target="_blank" href="http://codeinjection.blogspot.com/2011/02/pumping-lemma-and-why-its-slightly-more.html">here</a>.
<h2 id="conclusion">Conclusion</h2>
Finite State Machines are a theoretical framework we can use to model systems. Given a known set of states, the starting state, the accepting state and the rules to transition between states, we can determine if a sequence of inputs would be accepted.
The limited amount of states that can be modeled does not make these abstract machines suitable for all systems, as shown by the Pumping Lemma. Even so, Finite State Machines have many real-world applications and are popular because of their simplicity.