David Landup

Olivera Popović

Jovana Ninkovic

Graphs in Java: Depth-First Search (DFS)

Dhananjay Singh

Uploading Files with Spring Boot

Graphs in Java: Representing Graphs in Code

In Git, branches allow you to create different versions of your code from a snapshot in the repository. So if you have a new feature to develop, a bug to fix, or code to rewrite, you can easily <a target="_blank" href="/git-create-a-new-branch/">create a branch</a> that won't affect the master branch of your codebase.
When creating and using branches for such common development tasks, you'll often need to switch between branches, depending on the task you're currently working on. In this short article we'll look at the Git commands and options you can use to switch branches in a local repository.
The main command you'll need here is the <code>git checkout</code> command. The syntax is as follows:
<pre><code class="hljs">$ git checkout &lt;branch-name&gt;
</code></pre>
If you can't recall the exact name of the branch, or if you just want to see what all branches are available in the repository, use the <code>git branch</code> command. For example:
<pre><code class="hljs">$ git branch
* master
 issue-421
</code></pre>
So, for example, if you need to work on fixing a bug that has a dedicated branch, then you'll want to run the command like this:
<pre><code class="hljs">$ git checkout issue-421
Switched to branch &#x27;issue-421&#x27;
</code></pre>
Here, branch &quot;issue-421&quot; is an existing branch in our repository, as we saw from the <code>git branch</code> command earlier.
If your branch has not yet been created, then you can use the <code>-b</code> flag to create it and switch to it:
<pre><code class="hljs">$ git checkout -b issue-530
Switched to a new branch &#x27;issue-530&#x27;
$ git branch
 master
 issue-421
* issue-530
</code></pre>
Creating a branch in this way will base the new one off of HEAD. If, instead, you want your branch to be based off of a different branch, then pass the existing branch as another parameter:
<pre><code class="hljs">$ git checkout -b &lt;new-branch&gt; &lt;existing-branch&gt;
</code></pre>
Here are some additional resources on working with branches in Git:
<ul>
<li><a target="_blank" href="/git-create-a-new-branch/">Git: Create a New Branch</a></li>
<li><a target="_blank" href="/git-merge-branch-into-master/">Git: Merge Branch into Master</a></li>
<li><a target="_blank" href="/git-checkout-a-remote-branch/">Git: Checkout a Remote Branch</a></li>
<li><a target="_blank" href="/git-rename-a-local-and-remote-branch/">Git: Rename a Local and Remote Branch</a></li>
</ul>

Scott Robinson

Git: Switch Branch

Usman Malik

Solving Sequence Problems with LSTM in Keras: Part 2

As your project changes over time, at some point you'll likely need to remove a file, or an entire directory, from the repository. Since this involves more than changing the contents of a file, Git has a special command to handle removing files, which also takes some important flags depending on your use-case.
In this short article we'll take a look at the <code>git rm</code> command and how to use it to remove files and directories from your repository.
<h2 id="removingafile">Removing a File</h2>
The simplest usage of this command is to remove a single file from the repository, which you can do so using the following syntax:
<pre><code class="hljs">$ git rm &lt;filename&gt;
</code></pre>
Let's say we have a Git repo with the following contents:
<pre><code class="hljs">$ git ls-files
.gitignore
index.js
lib/api.js
lib/db.js
package.json
</code></pre>
For whatever reason, suppose we no longer need the <code>lib/db.js</code> file. In order to remove it from our repo, we'd run the following:
<pre><code class="hljs">$ git rm lib/db.js 
rm &#x27;lib/db.js&#x27;
</code></pre>
Now, listing our repo files again shows that it was removed:
<pre><code class="hljs">$ git ls-files
.gitignore
index.js
lib/api.js
package.json
</code></pre>
However, we're not quite done. If you run the <code>status</code> command, you'll notice that the removal of the file is still in staging and needs to be committed to the repo, just like any other change you make.
<pre><code class="hljs">$ git status
On branch master
Changes to be committed:
 (use &quot;git reset HEAD &lt;file&gt;...&quot; to unstage)

 deleted: lib/db.js
$ git commit -m &quot;Removed db.js file&quot;
[master cf191e4] Removed db.js file
 1 file changed, 0 insertions(+), 0 deletions(-)
 delete mode 100644 lib/db.js
</code></pre>
<h2 id="removingmultiplefiles">Removing Multiple Files</h2>
Removing multiple files from a repo is very similar to the previous use-case of removing a single file. Depending on your preferred method, there are a few ways to do this. For example, you can simply explicitly list all files to be removed:
<pre><code class="hljs">$ git rm lib/db.js lib/api.js
rm &#x27;lib/api.js&#x27;
rm &#x27;lib/db.js&#x27;
</code></pre>
Or, if there are more files than you feel like listing, you can always use the wildcard character:
<pre><code class="hljs">$ git rm lib/*.js
rm &#x27;lib/api.js&#x27;
rm &#x27;lib/db.js&#x27;
</code></pre>
Note that by removing all of the contents from the <code>lib</code> directory, Git will also remove the actual directory itself. This is done because Git only tracks files, not directories:
<pre><code class="hljs">$ git ls-files
.gitignore
index.js
package.json
</code></pre>
<h2 id="removingadirectory">Removing a Directory</h2>
In order to remove an entire directory from your Git repository, all you need to do is remove all files in that directory from the repo. This can be done using one of methods above if there aren't many files, but in a lot of cases this would become too cumbersome. In this case, the best option would be to recursively remove all files using the <code>-r</code> flag.
<pre><code class="hljs">$ git rm -r &lt;directory&gt;
</code></pre>
For this example, we'll work off of our example above, and adding some more files to our <code>lib</code> directory:
<pre><code class="hljs">$ git ls-files
.gitignore
index.js
lib/apis/aws.js
lib/apis/github.js
lib/apis/stripe.js
lib/db.js
package.json
</code></pre>
Here we have nested files and directories within <code>lib</code>. To remove the entire <code>lib</code> directory from the repo altogether, we can use the <code>-r</code> flag:
<pre><code class="hljs">$ git rm -r lib
rm &#x27;lib/apis/aws.js&#x27;
rm &#x27;lib/apis/github.js&#x27;
rm &#x27;lib/apis/stripe.js&#x27;
rm &#x27;lib/db.js&#x27;
</code></pre>
Notice that this handles the removal of all files under <code>lib</code>, and even <code>lib/apis</code>, since it recursively searches the directory.
And finally, don't forget to commit your changes:
<pre><code class="hljs">$ git status
On branch master
Changes to be committed:
 (use &quot;git reset HEAD &lt;file&gt;...&quot; to unstage)

 deleted: lib/apis/aws.js
 deleted: lib/apis/github.js
 deleted: lib/apis/stripe.js
 deleted: lib/db.js

$ git commit -am &quot;Removed lib directory&quot;
[master 53fc6af] Removed lib directory
 4 files changed, 0 insertions(+), 0 deletions(-)
 delete mode 100644 lib/apis/aws.js
 delete mode 100644 lib/apis/github.js
 delete mode 100644 lib/apis/stripe.js
 delete mode 100644 lib/db.js
</code></pre>

Git: Remove a File

When starting a new project, one of the first things you'll find yourself needing to do is creating a new Git repository. This not only helps you share the project with coworkers, or publicly, but it's also a great way to track updates to a young project that is bound to go through significant changes in its early life. With a full history of those changes, and helpful features like <a target="_blank" href="/git-create-a-new-branch/">branches</a>, you can more easily test out different designs/implementations for the project without losing previous work.
As with anything in Git, there are a few ways to do what we want, depending on what you need. In this article we'll show a few ways to create a new repository.
<h2 id="creatingarepositoryfromscratch">Creating a Repository from Scratch</h2>
In order to start this new repo you'll want to use the <code>init</code> command. To do this, go to your project directory and type the following:
<pre><code class="hljs">$ git init
Initialized empty Git repository in /Users/scott/projects/my-new-project/.git/
</code></pre>
This can be done at any time in your project, whether there are already files there or not. Once you've added some files and feel like you're at a point in which you should commit your code, you can use the <code>add</code> command to add your files to the new repo:
<pre><code class="hljs">$ git add .
</code></pre>
This will stage the files in your current working directory for the next commit. After staging our files, we can verify that they are ready to commit by 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: index.js
 new file: package.json
</code></pre>
Finally, you can commit the files to the new repo using <code>commit</code>:
<pre><code class="hljs">$ git commit -am &quot;Initial commit&quot;
[master (root-commit) 37a82f5] Initial commit
 2 files changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 index.js
 create mode 100644 package.json
</code></pre>
Here we also use the flags <code>-a</code> and <code>-m</code>, which do the following:
<ul>
<li><code>-a</code>: Commit all staged files</li>
<li><code>-m</code>: Use the following string as the commit message</li>
</ul>
To verify
<h2 id="creatingarepositoryforanexistingproject">Creating a Repository for an Existing Project</h2>
Creating a repository for an existing project is virtually the same process as creating a repository for a new project. Just as in the last section, you'll want to execute the same general commands:
<pre><code class="hljs">$ git init
Initialized empty Git repository in /Users/scott/projects/my-new-project/.git/
$ git add .
$ git commit -am &quot;Initial commit&quot;
[master (root-commit) 37a82f5] Initial commit
 2 files changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 index.js
 create mode 100644 package.json
</code></pre>
Note that the <code>git add .</code> command will add all files in the current working directory, including those in subdirectories. However, it will also add some files or directories that you might not want, like <code>node_modules</code> for a Node.js project. In order to avoid including unwanted files/directories like this, you should create and commit a <code>.gitignore</code> file.
Backing up a little, our commands to create a repository for an existing project may look more like this:
<pre><code class="hljs">$ git init
Initialized empty Git repository in /Users/scott/projects/my-new-project/.git/
$ echo &quot;node_modules/&quot; &gt; .gitignore
$ echo &quot;package-lock.json&quot; &gt;&gt; .gitignore
$ git add .
</code></pre>
Now when these &quot;ignored&quot; items are present in your project you don't need to worry about accidentally staging and committing them. For example:
<pre><code class="hljs">$ npm install
$ ls -l
total 40
-rw-r--r-- 1 scott staff 0 Sep 16 15:15 index.js
drwxr-xr-x 4 scott staff 136 Sep 16 15:27 lib
drwxr-xr-x 52 scott staff 1768 Sep 16 15:32 node_modules
-rw-r--r-- 1 scott staff 14233 Sep 16 15:32 package-lock.json
-rw-r--r-- 1 scott staff 362 Sep 16 15:32 package.json
$ git add .
$ git status
On branch master

Initial commit

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

 new file: .gitignore
 new file: index.js
 new file: lib/api.js
 new file: lib/db.js
 new file: package.json

$ git commit -am &quot;Initial commit&quot;
[master (root-commit) 9646a88] Initial commit
 5 files changed, 19 insertions(+)
 create mode 100644 .gitignore
 create mode 100644 index.js
 create mode 100644 lib/api.js
 create mode 100644 lib/db.js
 create mode 100644 package.json
</code></pre>
Notice that our ignored file (<code>package-lock.json</code>) and directory (node_modules) are not included in staging, even after executing <code>git add .</code>, or the commit.
Note: Using <code>.gitignore</code> is not only recommended when creating a repo for an existing project, but we reference it here because you're more likely to need it for an existing project, as more mature projects tend to accumulate files that shouldn't be tracked or shared between users.
<h2 id="cloninganexistingproject">Cloning an Existing Project</h2>
Although you aren't technically creating a new repo, in this use-case you can clone an existing one, preventing you from needing to <code>git init</code> one yourself. This is very common for when you're needing to make updates to an existing project, or maybe if you want to clone a skeleton project to help get you started.
In order to clone a repo, you'll want to use the <code>clone</code> command:
<pre><code class="hljs">$ git clone &lt;repo-url&gt;
</code></pre>
This will copy all of the contents of the repository to your current working directory under the name of the repository. For example:
<pre><code class="hljs">$ git clone git@github.com:scottwrobinson/twentyjs.git
Cloning into &#x27;twentyjs&#x27;...
remote: Enumerating objects: 48, done.
remote: Total 48 (delta 0), reused 0 (delta 0), pack-reused 48
Receiving objects: 100% (48/48), 9.35 KiB | 0 bytes/s, done.
Resolving deltas: 100% (22/22), done.
$ ls -l
total 0
drwxr-xr-x 9 scott staff 306 Sep 16 15:55 twentyjs
</code></pre>
There are a number of other options and use-cases for this command, but they aren't in the scope of this article, so we won't cover them here. For more info, check out the article <a target="_blank" href="/git-clone-a-repository/">Git: Clone a Repository</a>.

Git: Create a New Repository

<h2 id="introduction">Introduction</h2>
In this tutorial, we're going to learn how to use the <a rel="nofollow" target="_blank" href="https://wiki.python.org/moin/YAML">YAML</a> library in Python 3. YAML stands for Yet Another Markup Language.
In recent years it has become very popular for its use in storing data in a serialized manner for configuration files. Since YAML essentially is a data format, the YAML library is quite brief, as the only functionality required of it is the ability to parse YAML formatted files.
In this article we will start with seeing how data is stored in a YAML file, followed by loading that data into a Python object. Lastly, we will learn how to store a Python object in a YAML file. So, let's begin.
Before we move further, there are a few prerequisites for this tutorial. You should have a basic understanding of Python's syntax, and/or have done at least beginner level programming experience with some other language. Other than that, the tutorial is quite simple and easy to follow for beginners.
<h2 id="installation">Installation</h2>
The installation process for YAML is fairly straight forward. There are two ways to do it; we'll start with the easy one first:
<h3 id="method1viapip">Method 1: Via Pip</h3>
The easiest way to install the YAML library in Python is via the <a rel="nofollow" target="_blank" href="https://pypi.org/project/pip/">pip</a> package manager. If you have pip installed in your system, run the following command to download and install YAML:
<pre><code class="hljs">$ pip install pyyaml
</code></pre>
<h3 id="method2viasource">Method 2: Via Source</h3>
In case you do not have pip installed, or are facing some problem with the method above, you can go to the library's <a rel="nofollow" target="_blank" href="https://github.com/yaml/pyyaml">source page</a>. Download the repository as a zip file, open the terminal or command prompt, and navigate to the directory where the file is downloaded. Once you are there, run the following command:
<pre><code class="hljs">$ python setup.py install
</code></pre>
<h2 id="yamlcodeexamples">YAML Code Examples</h2>
In this section, we will learn how to handle (manipulate) YAML files, starting with how to read them i.e. how to load them into our Python script so that we can use them as per our needs. So, let's start.
<h3 id="readingyamlfilesinpython">Reading YAML Files in Python</h3>
In this section, we will see how to read YAML files in Python.
Let's start by making two YAML formatted files.
The contents of the first file are as follows:
<pre><code class="hljs"># fruits.yaml file

apples: 20
mangoes: 2
bananas: 3
grapes: 100
pineapples: 1
</code></pre>
The contents of the second file are as follows:
<pre><code class="hljs"># categories.yaml file

sports:

 - soccer
 - football
 - basketball
 - cricket
 - hockey
 - table tennis

countries:

 - Pakistan
 - USA
 - India
 - China
 - Germany
 - France
 - Spain
</code></pre>
You can see that the <code>fruits.yaml</code> and <code>categories.yaml</code> files contain different types of data. The former contains information only about one entity, i.e. fruits, while the latter contains information about sports and countries.
Let's now try to read the data from the two files that we created using a Python script. The <code>load()</code> method from the <code>yaml</code> module can be used to read YAML files. Look at the following script:
<pre><code class="hljs"># process_yaml.py file

import yaml

with open(r&#x27;E:\data\fruits.yaml&#x27;) as file:
 # The FullLoader parameter handles the conversion from YAML
 # scalar values to Python the dictionary format
 fruits_list = yaml.load(file, Loader=yaml.FullLoader)

 print(fruits_list)
</code></pre>
Output:
<pre><code class="hljs">{ 'apples': 20, 'mangoes': 2, 'bananas': 3, 'grapes': 100, 'pineapples': 1 }
</code></pre>
In the script above we specified <code>yaml.FullLoader</code> as the value for the <code>Loader</code> parameter which loads the full YAML language, avoiding the arbitrary code execution. Instead of using the <code>load</code> function and then passing <code>yaml.FullLoader</code> as the value for the <code>Loader</code> parameter, you can also use the <code>full_load()</code> function, as we will see in the next example.
Let's now try and read the second YAML file in a similar manner using a Python script:
<pre><code class="hljs"># read_categories.py file

import yaml

with open(r&#x27;E:\data\categories.yaml&#x27;) as file:
 documents = yaml.full_load(file)

 for item, doc in documents.items():
 print(item, &quot;:&quot;, doc)
</code></pre>
Since there are 2 documents in the <code>categories.yaml</code> file, we ran a loop to read both of them.
Output:
<pre><code class="hljs">sports : ['soccer', 'football', 'basketball', 'cricket', 'hockey', 'table tennis']
countries : ['Pakistan', 'USA', 'India', 'China', 'Germany', 'France', 'Spain']
</code></pre>
As you can see from the last two examples, the library automatically handles the conversion of YAML formatted data to Python dictionaries and lists.
<h3 id="writingyamlfilesinpython">Writing YAML Files in Python</h3>
Now that we have learned how to convert a YAML file into a Python dictionary, let's try to do things the other way around i.e. serialize a Python dictionary and store it into a YAML formatted file. For this purpose, let's use the same dictionary that we got as an output from our last program.
<pre><code class="hljs">import yaml

dict_file = [{&#x27;sports&#x27; : [&#x27;soccer&#x27;, &#x27;football&#x27;, &#x27;basketball&#x27;, &#x27;cricket&#x27;, &#x27;hockey&#x27;, &#x27;table tennis&#x27;]},
{&#x27;countries&#x27; : [&#x27;Pakistan&#x27;, &#x27;USA&#x27;, &#x27;India&#x27;, &#x27;China&#x27;, &#x27;Germany&#x27;, &#x27;France&#x27;, &#x27;Spain&#x27;]}]

with open(r&#x27;E:\data\store_file.yaml&#x27;, &#x27;w&#x27;) as file:
 documents = yaml.dump(dict_file, file)
</code></pre>
The <code>dump()</code> method takes the Python dictionary as the first, and a File object as the second parameter.
Once the above code executes, a file named <code>store_file.yaml</code> will be created in your current working directory.
<pre><code class="hljs"># store_file.yaml file contents:

- sports:

 - soccer
 - football
 - basketball
 - cricket
 - hockey
 - table tennis
- countries:

 - Pakistan
 - USA
 - India
 - China
 - Germany
 - France
 - Spain
</code></pre>
Another useful functionality that the YAML library offers for the <code>dump()</code> method is the <code>sort_keys</code> parameter. To show what it does, let's apply it on our first file, i.e. <code>fruits.yaml</code>:
<pre><code class="hljs">import yaml

with open(r&#x27;E:\data\fruits.yaml&#x27;) as file:
 doc = yaml.load(file, Loader=yaml.FullLoader)

 sort_file = yaml.dump(doc, sort_keys=True)
 print(sort_file)
</code></pre>
Output:
<pre><code class="hljs">apples: 20
bananas: 3
grapes: 100
mangoes: 2
pineapples: 1
</code></pre>
You can see in the output that the fruits have been sorted in the alphabetical order.
<h2 id="conclusion">Conclusion</h2>
In this brief tutorial, we learned how to install Python's YAML library (PyYAML) to manipulate YAML formatted files. We covered loading the contents of a YAML file into our Python program as dictionaries, as well as serializing Python dictionaries into YAML files and storing their keys. The library is quite brief and only offers basic functionalities.

Muhammad Junaid Khalid

Reading and Writing YAML to a File in Python

Solving Sequence Problems with LSTM in Keras