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

<h2 id="introduction">Introduction</h2>
A lot of applications handle files in some way and file manipulation is one of the core knowledges in any programming language.
In order to manipulate files, we need to know where they're located. Having an overview of files in a directory is paramount if we want to accomplish this, especially if we can perform operations on them through iteration. There are several ways to do this in Java, which we'll show throughout this article.
For the sake of simplicity, all examples will be written for the following file tree:
<pre><code class="hljs">Programming
|-- minimax.c
|-- super_hack.py
|-- TODO.txt
`-- CodingMusic
 |-- Girl Talk - All Day.mp3
 |-- Celldweller - Frozen.mp3
 |-- Lim Taylor - Isn't It Wonderful.mp3
 `-- Radiohead - Everything in Its Right Place.mp3
</code></pre>
<h2 id="filelist">File.list()</h2>
The simplest method to list the names of files and folders in a given directory, without traversing the sub-directories, is the helper method <code>.list()</code>, which returns an array of <code>String</code>s.
We do this by using the <code>.list()</code> method on a <code>File</code> instance:
<pre><code class="hljs">public class Pathnames {

 public static void main(String[] args) {
 // Creates an array in which we will store the names of files and directories
 String[] pathnames;

 // Creates a new File instance by converting the given pathname string
 // into an abstract pathname
 File f = new File(&quot;D:/Programming&quot;);

 // Populates the array with names of files and directories
 pathnames = f.list();

 // For each pathname in the pathnames array
 for (String pathname : pathnames) {
 // Print the names of files and directories
 System.out.println(pathname);
 }
 }
}
</code></pre>
Using a simple <a target="_blank" href="/java-flow-control-for-and-for-each-loops/">for-each</a> loop, we iterate through the array and print out the <code>String</code>s.
<pre><code class="hljs">CodingMusic
minimax.c
super_hack.py
TODO.txt
</code></pre>
Using this approach, all of the items in the <code>CodingMusic</code> directory aren't shown, and a downside to this approach is that we can't really do anything to the files themselves. We're just getting their names. It's useful when we just want to take a look at the files at face-value.
<h3 id="filenamefilter">FilenameFilter</h3>
Another thing we can do with the <code>.list()</code> method is to create a <code>FilenameFilter</code> to return only the files we want:
<pre><code class="hljs">File f = new File(&quot;D:/Programming&quot;);

// This filter will only include files ending with .py
FilenameFilter filter = new FilenameFilter() {
 @Override
 public boolean accept(File f, String name) {
 return name.endsWith(&quot;.py&quot;);
 }
 };

// This is how to apply the filter
pathnames = f.list(filter);
</code></pre>
Running this piece of code would yield:
<pre><code class="hljs">super_hack.py
</code></pre>
<h2 id="filelistfiles">File.listFiles()</h2>
Similar to the previous method, this one can be used to return the names of files and directories, but this time we get them as an array of <code>File</code> objects, which gives us the ability to directly manipulate them:
<pre><code class="hljs">public class Pathnames {
 public static void main(String args[]) {

 // try-catch block to handle exceptions
 try {
 File f = new File(&quot;D:/Programming&quot;);

 FilenameFilter filter = new FilenameFilter() {
 @Override
 public boolean accept(File f, String name) {
 // We want to find only .c files
 return name.endsWith(&quot;.c&quot;);
 }
 };

 // Note that this time we are using a File class as an array,
 // instead of String
 File[] files = f.listFiles(filter);

 // Get the names of the files by using the .getName() method
 for (int i = 0; i &lt; files.length; i++) {
 System.out.println(files[i].getName());
 }
 } catch (Exception e) {
 System.err.println(e.getMessage());
 }
 }
}
</code></pre>
Output:
<pre><code class="hljs">minimax.c
</code></pre>
Now, let's traverse deeper into the file system using recursion and some more methods to use on the <code>File</code> object:
<pre><code class="hljs">public class ListFilesRecursively {
 public void listFiles(String startDir) {
 File dir = new File(startDir);
 File[] files = dir.listFiles();

 if (files != null &amp;&amp; files.length &gt; 0) {
 for (File file : files) {
 // Check if the file is a directory
 if (file.isDirectory()) {
 // We will not print the directory name, just use it as a new
 // starting point to list files from
 listDirectory(file.getAbsolutePath());
 } else {
 // We can use .length() to get the file size
 System.out.println(file.getName() + &quot; (size in bytes: &quot; + file.length()+&quot;)&quot;);
 }
 }
 }
 }
 public static void main(String[] args) {
 ListFilesRecursively test = new ListFilesRecursively();
 String startDir = (&quot;D:/Programming&quot;);
 test.listFiles(startDir);
 }
}
</code></pre>
Output:
<pre><code class="hljs">Girl Talk - All Day.mp3 (size in bytes: 8017524)
Celldweller - Frozen.mp3 (size in bytes: 12651325)
Lim Taylor - Isn't It Wonderful.mp3 (size in bytes: 6352489)
Radiohead - Everything in Its Right Place.mp3 (size in bytes: 170876098)
minimax.c (size in bytes: 20662)
super_hack.py (size in bytes: 114401)
TODO.txt (size in bytes: 998)
</code></pre>
<h2 id="fileswalk">Files.walk()</h2>
In Java 8 and later we can use the <code>java.nio.file.Files</code> class to populate a <code>Stream</code> and use that to go through files and directories, and at the same time recursively walk all subdirectories.
Note that in this example we will be using <a target="_blank" href="/lambda-expressions-in-java/">Lambda Expressions</a>:
<pre><code class="hljs">public class FilesWalk {
 public static void main(String[] args) {
 try (Stream&lt;Path&gt; walk = Files.walk(Paths.get(&quot;D:/Programming&quot;))) {
 // We want to find only regular files
 List&lt;String&gt; result = walk.filter(Files::isRegularFile)
 .map(x -&gt; x.toString()).collect(Collectors.toList());

 result.forEach(System.out::println);
 } catch (IOException e) {
 e.printStackTrace();
 }
 }
}
</code></pre>
Here, we've populated a <code>Stream</code> using the <code>.walk()</code> method, passing a <code>Paths</code> argument. The <code>Paths</code> class consists of static methods that return a <code>Path</code> based on a String URI - and using a <code>Path</code>, we can locate the file easily.
The <code>Path</code>, <code>Paths</code>, <code>Files</code>, and many other classes belong to the <code>java.nio</code> package, which was introduced in Java 7 as a more modern way to represent files in a non-blocking way.
Then, using the Collections Framework, a list is generated.
Running this piece of code will yield:
<pre><code class="hljs">D:\Programming\Coding Music\Radiohead - Everything in Its Right Place.mp3
D:\Programming\Coding Music\Lim Taylor - Isn't It Wonderful.mp3
D:\Programming\Coding Music\Celldweller - Frozen.mp3
D:\Programming\Coding Music\Girl Talk - All Day.mp3
D:\Programming\minimax.c
D:\Programming\super_hack.py
D:\Programming\TODO.txt
</code></pre>
<h2 id="conclusion">Conclusion</h2>
Handling files in some way is a core task for most programming languages, and this includes the ability to list and find files in the file system. In order to manipulate files, we need to know where they're located. Having an overview of files in a directory is paramount if we want to accomplish this, especially if we can perform operations on them through iteration.
In this article we showed a number of different ways in Java to list files on the file system, using both linear and recursive approaches.

Marko Petrović

Java: List Files in a Directory

<h2 id="introduction">Introduction</h2>
In this tutorial you will learn how to deploy a Flask application to Heroku. The app can be as simple as a &quot;Hello World&quot; app to a social media monitoring platform!
Nowadays there is no business that doesn't have a web app to help it a reach greater audience, or maybe provide its services through an online portal.
Today you are about to learn how to make an API using Flask as a case study for how to deploy your app on Heroku.
<h2 id="buildingarestapiwithflask">Building a REST API with Flask</h2>
In your project directory, let's start off by creating a <a target="_blank" href="/python-virtual-environments-explained/">virtualenv</a>:
<pre><code class="hljs">$ python -m venv venv/
</code></pre>
And let's activate it with the <code>source</code> command:
<pre><code class="hljs">$ source venv/bin/activate
</code></pre>
Then, let's use <code>pip</code> to install the libraries we're going to use - <code>flask</code> to build the app and <code>gunicorn</code> as our server:
<pre><code class="hljs">$ pip install flask
$ pip install gunicorn
</code></pre>
Our application is going to be a simple API that receives a name and returns a welcome message:
<pre><code class="hljs"># app.py
from flask import Flask, request, jsonify
app = Flask(__name__)

@app.route(&#x27;/getmsg/&#x27;, methods=[&#x27;GET&#x27;])
def respond():
 # Retrieve the name from url parameter
 name = request.args.get(&quot;name&quot;, None)

 # For debugging
 print(f&quot;got name {name}&quot;)

 response = {}

 # Check if user sent a name at all
 if not name:
 response[&quot;ERROR&quot;] = &quot;no name found, please send a name.&quot;
 # Check if the user entered a number not a name
 elif str(name).isdigit():
 response[&quot;ERROR&quot;] = &quot;name can&#x27;t be numeric.&quot;
 # Now the user entered a valid name
 else:
 response[&quot;MESSAGE&quot;] = f&quot;Welcome {name} to our awesome platform!!&quot;

 # Return the response in json format
 return jsonify(response)

@app.route(&#x27;/post/&#x27;, methods=[&#x27;POST&#x27;])
def post_something():
 param = request.form.get(&#x27;name&#x27;)
 print(param)
 # You can add the test cases you made in the previous function, but in our case here you are just testing the POST functionality
 if param:
 return jsonify({
 &quot;Message&quot;: f&quot;Welcome {name} to our awesome platform!!&quot;,
 # Add this option to distinct the POST request
 &quot;METHOD&quot; : &quot;POST&quot;
 })
 else:
 return jsonify({
 &quot;ERROR&quot;: &quot;no name found, please send a name.&quot;
 })

# A welcome message to test our server
@app.route(&#x27;/&#x27;)
def index():
 return &quot;&lt;h1&gt;Welcome to our server !!&lt;/h1&gt;&quot;

if __name__ == &#x27;__main__&#x27;:
 # Threaded option to enable multiple instances for multiple user access support
 app.run(threaded=True, port=5000)
</code></pre>
To test your application locally, let's hit the <a rel="nofollow" target="_blank" href="http://127.0.0.1:5000/">http://127.0.0.1:5000/</a> endpoint. If everything is fine, we should be greeted with a welcome message:
<img src="https://stackabuse.s3.amazonaws.com/media/deploying-a-flask-application-to-heroku-1.png" alt="welcome message">
We can also send a name as a parameter, such as <code>http://localhost:5000/getmsg/?name=Mark</code>:
<pre><code class="hljs">{&quot;MESSAGE&quot;:&quot;Welcome Mark to our awesome platform!!&quot;}
</code></pre>
With our application ready, let's deploy it to Heroku.
<h2 id="heroku">Heroku</h2>
<a rel="nofollow" target="_blank" href="https://www.heroku.com">Heroku</a> is one of the first cloud platform as a service (PaaS) and supports several languages - Ruby, Java, Node.js, Scala, Clojure, Python, PHP, and Go.
The first thing we need to do is define which libraries our application uses. That way, Heroku knows which ones to provide for us, similar to how we install them locally when developing the app.
To achieve this, we need to create a <code>requirements.txt</code> file with all of the modules:
<pre><code class="hljs">$ pip freeze &gt; requirements.txt
</code></pre>
This way we end up with a <code>requirements.txt</code> file that contains the libraries we're using and their versions:
<pre><code class="hljs">Click==7.0
Flask==1.1.1
gunicorn==19.9.0
itsdangerous==1.1.0
Jinja2==2.10.1
MarkupSafe==1.1.1
Werkzeug==0.15.6
</code></pre>
Note: One of the common mistakes is misspelling requirements, it is a real pain when you debug your code for hours and find out that the app doesn't run because the server didn't download the modules. The only way for Heroku to know the modules that you are using is to add them to the <code>requirements.txt</code> file, so be careful!
For Heroku to be able to run our application like it should, we need to define a set of processes/commands that it should run beforehand. These commands are located in the <code>Procfile</code>:
<pre><code class="hljs">web: gunicorn app:app
</code></pre>
The <code>web</code> command tells Heroku to start a web server for the application, using <code>gunicorn</code>. Since our application is called <code>app.py</code>, we've set the <code>app</code> name to be <code>app</code> as well.
<h3 id="herokuaccount">Heroku Account</h3>
Now, we should <a rel="nofollow" target="_blank" href="https://signup.heroku.com">create a Heroku account</a>.
Once that is out of the way, on the dashboard, select New -&gt; Create new app:
<img src="https://stackabuse.s3.amazonaws.com/media/deploying-a-flask-application-to-heroku-2.png" alt="new application">
Choose a name for the application and choose a region of where you'd like to host it:
<img src="https://stackabuse.s3.amazonaws.com/media/deploying-a-flask-application-to-heroku-3.png" alt="app naming">
Once the application is created on Heroku, we're ready to deploy it online.
<h3 id="git">Git</h3>
To upload our code, we'll use <a target="_blank" href="/tag/git/">Git</a>. First, let's make a git repository:
<pre><code class="hljs">$ git init .
</code></pre>
And now, let's add our files and <code>commit</code>:
<pre><code class="hljs">$ git add app.py Procfile requirements.txt
$ git commit -m &quot;first commit&quot;
</code></pre>
<h3 id="deployingtheapptoheroku">Deploying the App to Heroku</h3>
To finally deploy the application, we'll need to install the <a rel="nofollow" target="_blank" href="https://devcenter.heroku.com/articles/heroku-command-line">Heroku CLI</a> with which we'll run Heroku-related commands. Let's login to our account using our credentials by running the command:
<pre><code class="hljs">$ heroku login -i
</code></pre>
Alternatively, we can login using the browser if we run the command:
<pre><code class="hljs">$ heroku login
</code></pre>
At this point, while logged in, we should add our repository to the remote one:
<pre><code class="hljs">$ heroku git:remote -a {your-project-name}
</code></pre>
Be sure to replace <code>{your-project-name}</code> with the actual name of your project you selected in the earlier step.
And with that done, let's upload the project by <a target="_blank" href="/git-push-local-branch-and-track-it/">pushing</a> it to Heroku:
<pre><code class="hljs">$ git push heroku master
</code></pre>
A lengthy progress log should come up on your terminal, ending with:
<pre><code class="hljs">...
remote: -----&gt; Discovering process types
remote: Procfile declares types -&gt; web
remote:
remote: -----&gt; Compressing...
remote: Done: 45.1M
remote: -----&gt; Launching...
remote: Released v4
remote: https://{your-project-name}.herokuapp.com/ deployed to Heroku
remote:
remote: Verifying deploy... done.
To https://git.heroku.com/{your-project-name}.git
 ae85864..4e63b46 master -&gt; master
</code></pre>
Congratulations, you have successfully uploaded your first web app to Heroku! It's now time now to test and verify our API.
<h2 id="testingtheapi">Testing the API</h2>
In the log that has been shown in the console you will find a link for your application <code>https://{your-project-name}.herokuapp.com/</code>, this link can also be found under the Settings tab, in the Domains and certificates section:
<img src="https://stackabuse.s3.amazonaws.com/media/deploying-a-flask-application-to-heroku-4.png" alt="application url">
Visiting the link, we can reach our application, which is now online and public:
<img src="https://stackabuse.s3.amazonaws.com/media/deploying-a-flask-application-to-heroku-5.png" alt="welcome message">
In case there were any errors, you can access the logs and troubleshoot from there:
<img src="https://stackabuse.s3.amazonaws.com/media/deploying-a-flask-application-to-heroku-6.png" alt="log link">
You can manually test your app in the browser, by typing the URL and adding the path for the <code>/getmsg/</code> route. Though, as applications tend to get more and more complex, it's advised to use tools like <a rel="nofollow" target="_blank" href="https://www.getpostman.com">Postman</a>.
Now let's test the <code>GET</code> request to our application with a <code>name</code> parameter:
<img src="https://stackabuse.s3.amazonaws.com/media/deploying-a-flask-application-to-heroku-7.png" alt="local request with parameters">
Now let's test a URL that isn't bound to any function, like for example <code>/newurl</code>, with a GET request:
<img src="https://stackabuse.s3.amazonaws.com/media/deploying-a-flask-application-to-heroku-8.png" alt="new url">
As expected, our Flask app returned a 404 response.
Note: You can change the view of the output from Pretty, Raw, and Preview, which shows you how the output would look in your browser.
Now let's test a <code>POST</code> request:
<img src="https://stackabuse.s3.amazonaws.com/media/deploying-a-flask-application-to-heroku-9.png" alt="post request">
Also, let's see what happens if we completely omit the <code>name</code> parameter:
<pre><code class="hljs">{&quot;ERROR&quot;:&quot;no name found, please send a name.&quot;}
</code></pre>
We've tested our app and confirmed that everything is working fine. To see the history of your server and what requests were made you can check the logs for your site via Heroku:
<img src="https://stackabuse.s3.amazonaws.com/media/deploying-a-flask-application-to-heroku-10.png" alt="Heroku log">
You can see here the <code>POST</code> request we made to our page <code>/post/</code>.
Also, you can see the history of building the application. Moreover, if there's any problem during building you can find it in the log page.
<h2 id="conclusion">Conclusion</h2>
In this article we showed a simple example of building our first simple API on Heroku using the Flask micro-framework. The development process remains the same as you continue to build your application.
Heroku offers a free plan and Student plans. The free plan is limited but it works pretty good for a starting app, POC, or a simple project for example. However, if you want to scale your application then you'll want to consider one of the plans that are available on the site from <a rel="nofollow" target="_blank" href="https://www.heroku.com/pricing">here</a>.
For more info on Heroku you can check the Heroku <a rel="nofollow" target="_blank" href="https://devcenter.heroku.com/articles/getting-started-with-python">manual itself</a>.

Ali Abdelaal

Deploying a Flask Application to Heroku

<h2 id="introduction">Introduction</h2>
Conditional statements and loops are a very important tool in programming. There aren't many things we could do with code that can only execute line-by-line.
That's what &quot;flow control&quot; means - guiding the execution of our program, instead of letting it execute line-by-line regardless of any internal or external factors. Every programming language supports some form of flow control, if not explicitly via <code>if</code>s and <code>for</code>s or similar statements - then it implicitly gives us the tools to create such constructs, i.e. low-level programming languages usually achieve that affect with a lot of <code>go-to</code> commands.
<blockquote>
Loops were a concept used long before computer programming was even a thing, but the first person to use a software loop was Ada Lovelace, commonly known by her maiden name - Byron, while calculating <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Bernoulli_number">Bernoulli numbers</a>, back in the 19th century.
</blockquote>
In Java, there are several ways to control the flow of the code:
<ul>
<li><a target="_blank" href="/java-flow-control-if-and-if-else-statements">if and if-else statements</a></li>
<li><a target="_blank" href="/flow-control-in-java-the-switch-statement">switch statements</a></li>
<li><a target="_blank" href="/java-flow-control-while-and-do-while-statements/"><code>while</code> and <code>do-while</code> statements</a></li>
<li><a target="_blank" href="/java-flow-control-for-and-for-each-loops/"><code>for</code> and <code>enhanced for</code> statements</a></li>
<li><a target="_blank" href="/java-flow-control-break-and-continue-statements/"><code>break</code> and <code>continue</code> statements</a></li>
</ul>
<h2 id="break">break</h2>
The <code>break</code> statement is one of Java's &quot;jump statements&quot;, since it transfers the code execution to another part of code. We've already seen the <code>break</code> keyword used in the <a target="_blank" href="/java-flow-control-the-switch-statement">switch statement</a>. We'll revisit it here, along with other use cases:
<ul>
<li>It can be used to stop execution of a <code>switch</code> statement case, instead of letting it continue executing code for following cases as well</li>
<li>It can be used to exit a loop before it has finished all its iterations, or as a form of exiting purposefully-created infinite loops</li>
<li>It can be used as an acceptable form of the &quot;go-to&quot; statement when we have multiple nested loops</li>
</ul>
The first two are relatively similar, since both are used to prematurely end the execution of one or more blocks of code:
<pre><code class="hljs">// Finding at which index element a is in an array
int[] arr = {1,2,3,4,5,6};
int foundAt = -1;

int a = 4;

for (int i = 0; i &lt; arr.length; i++) {
 System.out.println(arr[i]);
 if (arr[i] == a) {
 foundAt = i;
 break;
 }
}
if (foundAt != -1)
 System.out.println(a + &quot; was found at index &quot; + foundAt);
else System.out.println(a + &quot; wasn&#x27;t found in the array&quot;);
</code></pre>
Output:
<pre><code class="hljs">1
2
3
4
4 was found at index 3
</code></pre>
As we can see, the <code>for</code> loop executed as usual until it ran into the <code>break</code> statement, at which point Java stopped executing the loop and continued execution at the first line after the <code>for</code> loop.
Here's another example:
<pre><code class="hljs">Scanner s = new Scanner(System.in);

while (true) {
 System.out.println(&quot;Do you wish to exit the infinite loop? Y/N&quot;);
 if (s.hasNext()) {
 String answer = s.next();
 if (answer.equals(&quot;Y&quot;) || answer.equals(&quot;y&quot;))
 break;
 }
}
</code></pre>
This loop will keep asking the user if he wishes to exit the loop until they either reply with the appropriate characters, where we exit the loop using <code>break</code>, or terminate the program with <code>Ctrl + C</code>.
By default the <code>break</code> statement only exits the innermost loop it's in.
If we wanted to find the first position at which a certain element can be found in a matrix, and we wanted to <code>break</code> out of the loops as soon as we found it (similar to the example with an array above), writing the following wouldn't work:
<pre><code class="hljs">int[][] matrix = {{1,2,3},{4,5,6},{7,8,9}};

int foundAtI = -1;
int foundAtJ = -1;

int a = 4;

for (int i = 0; i &lt; matrix.length; i++) {
 for (int j = 0; j &lt; matrix[i].length; j++) {
 System.out.print(matrix[i][j] + &quot; &quot;);
 if (matrix[i][j] == a) {
 foundAtI = i;
 foundAtJ = j;
 break;
 }
 }
 System.out.println();
}

System.out.println();
if (foundAtI != -1)
 System.out.println(a + &quot; was found at indices [&quot; + foundAtI + &quot;,&quot; + foundAtJ + &quot;]&quot;);
else System.out.println(a + &quot; wasn&#x27;t found in the matrix&quot;);
</code></pre>
Output:
<pre><code class="hljs">1 2 3 
4 
7 8 9 
4 was found at indices [1,0]
</code></pre>
We can see that the loop continued executing even after finding 4 in the matrix, after stuttering in the row in which 4 was located. This is because the <code>break</code> only exited the innermost loop, i.e. it stopped iterating through the current row and skipped to the next one. Furthermore, our task was to find the first occurrence of 4 in the matrix, and this way we'd return the last occurrence of 4 in our matrix.
This is where labeled statements come into play, which we'll take a look at next.
<h3 id="labeledstatements">Labeled Statements</h3>
Labeled statements can be used together with the <code>break</code> or <code>continue</code> statements to simulate a <code>go-to</code>.
Labels can be applied to any code block between <code>{}</code>, <code>for</code>, <code>for-each</code>, <code>while</code>, <code>do-while</code>, <code>if</code> and <code>switch</code> statements, as well as expressions, assignments, <code>return</code> statements, <code>try</code> blocks, and <code>throw</code> statements. We then use them with the <code>break</code> and <code>continue</code> statements.
Labels work by applying an identifier to a construct:
<pre><code class="hljs">Identifier : Construct
</code></pre>
Such as:
<pre><code class="hljs">someLoop: for (int i = 0; i &lt; 100; i++) {}
someLabel: {
 int i = 10;
}
</code></pre>
We can then call upon these labeled statements via a <code>break</code> or <code>continue</code>. For example, here we've labeled our outer loop as simply <code>outer</code>. In order to exit two or more nested loops, we <code>break</code> the outer loop by calling the label:
<pre><code class="hljs">outer: for (int i = 0; i &lt; matrix.length; i++) {
 for (int j = 0; j &lt; matrix[i].length; j++) {
 System.out.print(matrix[i][j] + &quot; &quot;);
 if (matrix[i][j] == a) {
 foundAtI = i;
 foundAtJ = j;
 break outer;
 }
 }
 System.out.println();
}
</code></pre>
Using this labeled loop in place of the loop in the example above yields the correct result and behavior:
<pre><code class="hljs">1 2 3
4
4 was found at indices [1,0]
</code></pre>
You can't use <code>break label</code> if the <code>break</code> isn't located within a block of code designated by that label or it will cause an error during compilation.
<h2 id="continue">continue</h2>
The <code>continue</code> statement simply skips the rest of the current iteration and proceeds to the next one. It's useful when we want to skip entire (or part of) iterations that meet certain conditions, especially if they're performance heavy.
For a <code>while</code> loop, &quot;skipping&quot; the rest of the iteration means going straight back to checking the condition before the next iteration, and for a <code>for</code> loop this means going to the &quot;step&quot; part of the <code>for</code> loop (the part where we usually increment/decrement the control variable) and then checking the condition before the next iteration.
<code>continue</code> is usually used with an <code>if</code> statement -&gt; we will <code>continue</code> if a certain condition is met. We use this <code>if</code> to execute the rest of the iteration only if the condition is not met, and skip using <code>continue</code>. For example
<pre><code class="hljs">// We want to print every number from 1 to 20, except those divisible by 3
for (int i = 1; i &lt;= 20; i++) {
 if (i % 3 == 0)
 continue;
 
 System.out.println(i);
}
</code></pre>
The <code>continue</code> in our example could easily be avoided by using a slightly modified <code>if</code> statement, mainly by printing the number if <code>i % 3 != 0</code> is true, otherwise doing nothing.
General advice regarding both <code>break</code> and (especially) <code>continue</code> is to try and use them mostly at the beginning of iterations as some form of preconditions that we're checking. Using a <code>continue</code> somewhere in the middle of the iteration is a great way to cause bugs that take you a while to figure out.
Of course, you can also use <code>continue</code> with labeled statements:
<pre><code class="hljs">start: for (int i = 0; i &lt; 10; i++) {
 System.out.println();
 for (int j = 0; j &lt; 10; j++) {
 if (j &gt;= i)
 continue start;
 }
 System.out.println(&quot;Since j will always be equal to or more than i, the &#x27;start&#x27; loop will continue running indefinitely, and this piece of code will never run.&quot;);
}
</code></pre>
<h2 id="conclusion">Conclusion</h2>
Flow control in code is essential just about every application. Statements that alter the flow of code are fundamental building blocks and every aspiring developer should be completely in control/aware of how they work.
Using the <code>break</code> and <code>continue</code> statements, Java developers can simulate <code>go-to</code> statements and break out of certain loops if need be.