<h2 id="introduction">Introduction</h2>
Scheduling a job in Jenkins is very useful when it comes to developing a great product. Imagine what a great advantage it is to transform a time-consuming task into an automated job. It doesn't need any supervision and as long as there are no errors in the workflow, you shouldn't have any worries.
In today's article we'll make a job that will run every five minutes and has the following output:
<pre><code class="hljs">Hello, World!
Today&#x27;s:
&lt;&lt;date&gt;&gt;
Here&#x27;s the current time:
&lt;&lt;time&gt;&gt;
</code></pre>
Additionally, we'll build a job that watches another project, and depending on its status, prints out an automated statement.
<h2 id="usecasesforautomationwithjenkins">Use-Cases for Automation with Jenkins</h2>
But before we dive into the technical part, let's take a moment to consider what can be automated in Jenkins. Of course, with a little imagination, you can tackle most problems and automate them. Let's take a look at an example that could be automated with Jenkins if you have a little (more) patience and you're also eager to deepen your Jenkins skills.
Products like Amazon Echo and Alexa could be configured to call Jenkins jobs that perform various actions. You could relatively easily integrate it into your smart home:
<ol>
<li>Say, &quot;Alexa, lock the doors&quot; (that would be the trigger, meaning Jenkins will listen to that event).</li>
<li>Alexa skill activates a Jenkins job.</li>
<li>Jenkins' job will use a script to call the smart doors locking system API.</li>
<li>Alexa waits for the Jenkins job to finish and tells you how it went, i.e. &quot;Door successfully locked&quot;, &quot;The doors are already locked&quot; or &quot;The doors could not be locked&quot;.</li>
</ol>
Of course, that's not a CI/CD job, but is well within the domain of possibilities for existing tech with Jenkins.
<h2 id="requirements">Requirements</h2>
<ul>
<li>A Jenkins server – for this tutorial, we'll use the official Docker image to set up a Jenkins server</li>
<li>A job that you'd like automated</li>
</ul>
<h2 id="creatingajenkinsjob">Creating a Jenkins Job</h2>
Login in to your Jenkins application and click on Create a Job. The type of job doesn't matter. It can be Freestyle, Maven, etc. All that matters is how we configure the scheduler.
For this article, we'll go with Pipeline. Choose a name for your project and save it:
<img src="https://stackabuse.s3.amazonaws.com/media/scheduling-a-job-with-jenkins-1.png" alt="create jenkins project">
Now, before we deal with the scheduling part, let's set up the Pipeline Groovy script which will print the message from the introduction.
Scroll down to Pipeline and add the following script:
<pre><code class="hljs">pipeline {
 agent any

 stages {
 stage(&#x27;Write Greetings&#x27;) {
 steps {
 echo &#x27;Hello, World!&#x27;
 }
 }
 
 stage(&#x27;Write Date&#x27;) {
 steps {
 print &#x27;Today\&#x27;s &#x27;
 print new Date().format(&quot;dd-MM-yyyy&quot;, TimeZone.getTimeZone(&quot;UTC&quot;))
 }
 }
 
 stage(&#x27;Write Hour&#x27;) {
 steps {
 print &#x27;Here\&#x27;s the current time &#x27;
 print new Date().format(&quot;HH:mm:ss&quot;, TimeZone.getTimeZone(&quot;UTC&quot;))
 }
 }
 }
}
</code></pre>
The script has three stages: Write Greetings, Write Date, and Write Hour. We use stages in order to better define and structure our script. Also, the stages can be viewed in the Jenkins UI.
In case one of them fails, you'll know which one:
<img src="https://stackabuse.s3.amazonaws.com/media/scheduling-a-job-with-jenkins-2.png" alt="Pipeline Groovy Script">
<h2 id="runningthejob">Running the Job</h2>
We have our job ready to be triggered! Let's click on Build Now and check the output:
<img src="https://stackabuse.s3.amazonaws.com/media/scheduling-a-job-with-jenkins-3.png" alt="Build the jenkins job">
<pre><code class="hljs">Started by user Alex
Running in Durability level: MAX_SURVIVABILITY
Running on Jenkins in /var/jenkins_home/workspace/Scheduled Pipeline
Hello, World!
Today&#x27;s:
24-12-2020
Here&#x27;s the current time:
16:00:38
Finished: SUCCESS
</code></pre>
You can also see on the Job's page the average time for every stage:
<img src="https://stackabuse.s3.amazonaws.com/media/scheduling-a-job-with-jenkins-4.png" alt="Jenkins Job Stage Details">
There are many ways to trigger a Jenkins job: manually (of course), using a Cron Expression, hooks, watching other projects, etc.
<h2 id="schedulingjenkinsjobswithcron">Scheduling Jenkins Jobs with Cron</h2>
Let's start with triggering a job via the Cron utility. We'll choose Build periodically and for the Schedule field use the following expression:
<pre><code class="hljs">H/5 * * * *
</code></pre>
<img src="https://stackabuse.s3.amazonaws.com/media/scheduling-a-job-with-jenkins-5.png" alt="Schedule the Jenkins Job">
This expression means the job will be executed every 5 minutes. A few useful examples of other patterns could be:
<ul>
<li><code>0 0 13 1/1 * ? *</code> – every hour, starting with 13:00;</li>
<li><code>0 0 17 ? * MON-FRI *</code> – every working day, at 5 PM;</li>
</ul>
If you don't want to learn this type of formatting in order to schedule your job, you can use a Cron Expression generator like <a rel="nofollow noopener" target="_blank" href="http://www.cronmaker.com/?1">CronMaker</a>.
Let's see the result. For this, we'll have to wait. After 10 minutes you should see that 2 jobs were triggered automatically:
<img src="https://stackabuse.s3.amazonaws.com/media/scheduling-a-job-with-jenkins-6.png" alt="Jenkins Job Results">
Notice the first job was executed at 9:12 PM, then at 9:17 PM, and the last at 9:22 PM. So the rule worked! We have a job which runs every 5 minutes.
<h2 id="schedulingajenkinsjobbywatchingotherprojects">Scheduling a Jenkins Job by Watching Other Projects</h2>
Now that we've seen how we can schedule a job periodically, let's create another one that triggers itself every time the first one was successful. Create another Pipeline project, and add the following code:
<pre><code class="hljs">pipeline {
 agent any

 stages {
 stage(&#x27;It worked&#x27;) {
 steps {
 echo &#x27;The other job worked!&#x27;
 }
 }
 }
}
</code></pre>
We have our pipeline script, let's schedule it. In the Build Triggers tab, select Build after other projects are built.
Enter the project which needs to be watched and select the cases when this one should be triggered:
<img src="https://stackabuse.s3.amazonaws.com/media/scheduling-a-job-with-jenkins-7.png" alt="Watch Projects">
Save it and let's wait for a little while. You should see the new job trigger itself every time the first one succeeds. You can see the details of the first run of this second job that was triggered by the job created before:
<img src="https://stackabuse.s3.amazonaws.com/media/scheduling-a-job-with-jenkins-8.png" alt="Jenkins Job Details">
Here's the output:
<pre><code class="hljs">Started by upstream project &quot;Scheduled Pipeline&quot; build number 7
originally caused by:
 Started by timer
Running in Durability level: MAX_SURVIVABILITY
Running on Jenkins in /var/jenkins_home/workspace/The other job worked
The other job worked!
Finished: SUCCESS
</code></pre>
<h2 id="conclusion">Conclusion</h2>
Automation is very useful and one of the key things technology brings us, regardless of the process you want to automate.
In this article, we've gone over how to schedule a job in Jenkins to run periodically using a Cron pattern, as well as to run when other projects are built.

Alex Chirea

In this tutorial, we'll go over examples on how to schedule a job in Jenkins to run periodically using Cron and how to run by watching other projects.

How to Schedule a Job with Jenkins

<h2 id="introduction">Introduction</h2>
Dictionaries are one of the most used data structures in all of software development, and for a good reason. They allow us to store our data in neat key, value pairs, which in turn gives us the ability to, on average, access our data in <code>O(1)</code> time.
While using a dictionary it's important to know how to iterate over it. Not being able to recover the data you stored makes it practically useless.
In this article, we'll see how to iterate through a Python dictionary with all kinds of iterators and the <code>for</code> loop.
<h2 id="usingthekeysmethod">Using the keys() Method</h2>
Python dictionaries have a handy method which allows us to easily iterate through all initialized keys in a dictionary, <code>keys()</code>.
Keep in mind that since Python 3, this method does not return a list, it instead returns a view object. A view object is exactly like the name says, a view of some data.
This means that we can iterate through said data no problem, but if we want to actually store the list of keys, we need to materialize it. Which can easily be done by forwarding the provided view object to a <code>list</code> constructor.
Let's take a look at how it all works:
<pre><code class="hljs">my_dict = {&#x27;alpha&#x27;: 5, &#x27;beta&#x27;: 4, &#x27;gamma&#x27;: 3}

# Here we&#x27;re just &#x27;looking&#x27; at the keys,
# we&#x27;re not actually constructing a list 
# out of them
key_view = my_dict.keys()
print(&quot;Key view:&quot;, key_view)
print(&quot;Type:&quot;, type(key_view),end=&quot;\n\n&quot;)

# Here we&#x27;re materializing the keys
# into a list ofo keys
key_list = list(my_dict.keys())
print(&quot;Key list:&quot;, key_list)
print(&quot;Type: &quot;, type(key_list),end=&quot;\n\n&quot;)

# And as we can see, view can be easily be
# used for iterating over a dictionary
for key in my_dict.keys():
 print(key, &#x27;:&#x27;, my_dict[key]) 
</code></pre>
Running the code gives us the following output:
<pre><code class="hljs">Key view: dict_keys([&#x27;alpha&#x27;, &#x27;beta&#x27;, &#x27;gamma&#x27;])
Type: &lt;class &#x27;dict_keys&#x27;&gt;

Key list: [&#x27;alpha&#x27;, &#x27;beta&#x27;, &#x27;gamma&#x27;]
Type: &lt;class &#x27;list&#x27;&gt;

alpha : 5
beta : 4
gamma : 3 
</code></pre>
An alternative way of doing this would be:
<pre><code class="hljs">my_dict = {&#x27;alpha&#x27;: 5, &#x27;beta&#x27;: 4, &#x27;gamma&#x27;: 3}

for key in my_dict:
 print(key, &#x27;:&#x27;, my_dict[key])
</code></pre>
When using the <code>in</code> keyword in conjunction with a dictionary, the dictionary invokes its <code>__iter__()</code> method. This method then returns an iterator which is used to implicitly go through the keys of the provided dictionary.
<h2 id="usingthevaluesmethod">Using the values() Method</h2>
Just like the <code>keys()</code> method, the <code>values()</code> method also return a view object, but instead of iterating through keys, it iterates through values:
<pre><code class="hljs">my_dict = {&#x27;alpha&#x27;: 5, &#x27;beta&#x27;: 4, &#x27;gamma&#x27;: 3}

# Inspecting the view of the values
# in the dictionary
key_list = list(my_dict.values())
print(&quot;Value list:&quot;, key_list)
print(&quot;Type: &quot;, type(key_list), end=&quot;\n\n&quot;)

for value in my_dict.values():
 print(value, end=&quot; &quot;)
</code></pre>
Running the code gives us the following output:
<pre><code class="hljs">Value list: [5, 4, 3]
Type: &lt;class &#x27;list&#x27;&gt;
5 4 3 
</code></pre>
Unlike the previous method, this one only provides values. It is useful when you are not concerned about keys.
<h2 id="usingtheitemsmethod">Using the items() method</h2>
Just like the <code>keys()</code> and <code>values()</code> methods, the <code>items()</code> method also returns a view object, but instead of just iterating through either <code>keys</code> or <code>values</code>, it iterates through <code>(key,value)</code> pairs.
Let's take a look at how it all works:
<pre><code class="hljs">my_dict = {&#x27;alpha&#x27;: 5, &#x27;beta&#x27;: 4, &#x27;gamma&#x27;: 3}

# Inspecting the view of the (key,value) pairs
key_list = list(my_dict.items())
print(&quot;(key,value) pair list:&quot;, key_list)
print(&quot;Type: &quot;, type(key_list), end=&quot;\n\n&quot;)

for item in my_dict.items():
 print(item, end=&quot; &quot;)
</code></pre>
Running the code gives us the following output:
<pre><code class="hljs">(key,value) pair list: [(&#x27;alpha&#x27;, 5), (&#x27;beta&#x27;, 4), (&#x27;gamma&#x27;, 3)]
Type: &lt;class &#x27;list&#x27;&gt;
(&#x27;alpha&#x27;, 5) (&#x27;beta&#x27;, 4) (&#x27;gamma&#x27;, 3) 
</code></pre>
To immediately assign both keys and values simultaneously, we can use tuple unpacking and extract them by using variables for each value in a tuple:
<pre><code class="hljs">for key, value in my_dict.items():
 print(key,&#x27;:&#x27;,value)
</code></pre>
It is important to note that in older Python 2 versions where <code>items()</code>, <code>keys()</code>, and <code>values()</code> returned a copy of data from a dictionary. While in Python 3 they return a view object.
These are more effective as they provide a dynamic view and, additionally if any changes are made in the original dictionary, they will immediately be reflected in the view object (and vice versa).
<h2 id="conclusion">Conclusion</h2>
In this article, we've covered different ways to iterate over a Python dictionary. This includes the <code>keys()</code>, <code>values()</code> and <code>items()</code> methods, with a <code>for</code> loop.

Guest Contributor

In this tutorial, we'll go over how to iterate through a dictionary in Python, using keys(), values() and items() and a for loop, with examples.

How to Iterate Over a Dictionary in Python

<h2 id="introduction">Introduction</h2>
A Stream is a sequence of objects that supports many different methods that can be combined to produce the desired result.
They can be created from numerous data sources, which are most often collections but can also be I/O channels, <code>Arrays</code>, primitive data types etc.
It's important to emphasize that a stream is not a data structure, since it doesn't store any data. It's just a data source wrapper which allows us to operate with data faster, easier and with cleaner code.
A stream also never modifies the original data structure, it just returns the result of the pipelined methods.
<h2 id="typesofstreams">Types of Streams</h2>
Streams can be sequential (created with <code>stream()</code>), or parallel (created with <code>parallelStream()</code>). Parallel streams can operate on multiple threads, while sequential streams can't.
Operations on streams can be either intermediate or terminal:
Intermediate operations on streams return a stream. This is why we can chain multiple intermediate operations without using semicolons. Intermediate operations include the following methods:
<ul>
<li><code>map(op)</code> - Returns a new stream in which the provided <code>op</code> function is applied to each of the elements in the original stream</li>
<li><code>filter(cond)</code> - Returns a new stream which only contains the elements from the original stream that satisfy the condition <code>cond</code>, specified by a predicate</li>
<li><code>sorted()</code> - Returns the original stream, but with the elements being sorted</li>
</ul>
Terminal operations are either void or return a non-stream result. They're called terminal because we can't chain any more stream operations once we've used a terminal one, without creating a new stream from it and starting again.
Some of the terminal operations are:
<ul>
<li><code>collect()</code> - Returns the result of the intermediate operations performed on the original stream</li>
<li><code>forEach()</code> - A void method used to iterate through the stream</li>
<li><code>reduce()</code> - Returns a single result produced from an entire sequence of elements in the original stream</li>
</ul>
In this tutorial, we'll go over the <code>map()</code> operation and how we can use it with Streams to convert/map objects of various types.
<h2 id="streammapexamples">Stream.map() Examples</h2>
Let's take a look at a couple of examples and see what we can do with the <code>map()</code> operation.
<h3 id="streamofintegerstostreamofstrings">Stream of Integers to Stream of Strings</h3>
<pre><code class="hljs">Arrays.asList(1, 2, 3, 4).stream()
 .map(n -&gt; &quot;Number &quot; + String.valueOf(n))
 .forEach(n -&gt; System.out.println(n + &quot; as a &quot; + n.getClass().getName()));
</code></pre>
Here, we've made a list of integers and called <code>stream()</code> on the list to create a new stream of data. Then, we've mapped each number <code>n</code> in the list, via the <code>map()</code> method, to a String. The Strings simply consist of <code>&quot;Number&quot;</code> and the <code>String.valueOf(n)</code>.
So for each number in our original list, we'll now have a <code>&quot;Number n&quot;</code> String corresponding to it.
Since <code>map()</code> returns a <code>Stream</code> again, we've used the <code>forEach()</code> method to print each element in it.
Running this code results in:
<pre><code class="hljs">Number 1 as a java.lang.String
Number 2 as a java.lang.String
Number 3 as a java.lang.String
Number 4 as a java.lang.String
</code></pre>
Note: This hasn't altered the original list in the slightest. We've simply processed the data and printed the results. If we wanted to persist this change, we'd <code>collect()</code> the data back into a <code>Collection</code> object such as a <code>List</code>, <code>Map</code>, <code>Set</code>, etc:
<pre><code class="hljs">List&lt;Integer&gt; list = Arrays.asList(1, 2, 3, 4);
 
List&lt;String&gt; mappedList = list.stream()
 .map(n -&gt; &quot;Number &quot; + String.valueOf(n))
 .collect(Collectors.toList());

System.out.println(list);
System.out.println(mappedList);
</code></pre>
This results in:
<pre><code class="hljs">[1, 2, 3, 4]
[Number 1, Number 2, Number 3, Number 4]
</code></pre>
<h3 id="streamofstringsintostreamofintegers">Stream of Strings into Stream of Integers</h3>
Now, let's do it the other way around - convert a stream of strings into a stream of integers:
<pre><code class="hljs">Arrays.asList(&quot;1&quot;, &quot;2&quot;, &quot;3&quot;, &quot;4&quot;).stream()
 .map(n -&gt; Integer.parseInt(n))
 .forEach(n -&gt; System.out.println(n));
</code></pre>
As expected, this code will produce the following output:
<pre><code class="hljs">1
2
3
4
</code></pre>
<h3 id="listofobjectsintolistofotherobjects">List of Objects into List of Other Objects</h3>
Let's say we have a class <code>Point</code> that represents one point in a cartesian coordinate system:
<pre><code class="hljs">public class Point {
 int X;
 int Y;
 
 Point(int x, int y){
 this.X=x;
 this.Y=y;
 }
 
 @Override
 public String toString() {
 return &quot;(&quot; + this.X + &quot;, &quot; + this.Y + &quot;)&quot;;
 }
 
}
</code></pre>
Then, say we want to scale a certain shape by a factor of <code>2</code>, this means we have to take all the points we have, and double both their <code>X</code> and <code>Y</code> values. This can be done by mapping the original values to their scaled counterparts.
Then, since we'd like to use the new coordinates, we'll collect this data into a new list of scaled points:
<pre><code class="hljs">List&lt;Point&gt; originalPoints = Arrays.asList(new Point(1, 2),
 new Point(3, 4),
 new Point(5, 6),
 new Point(7, 8));
System.out.println(&quot;Original vertices: &quot; + originalPoints);
 
List&lt;Point&gt; scaledPoints = originalPoints
 .stream()
 .map(n -&gt; new Point(n.X * 2, n.Y * 2))
 .collect(Collectors.toList());

System.out.println(&quot;Scaled vertices: &quot; + scaledPoints);
</code></pre>
This example will produce the following output:
<pre><code class="hljs">Original vertices: [(1, 2), (3, 4), (5, 6), (7, 8)]
Scaled vertices: [(2, 4), (6, 8), (10, 12), (14, 16)]
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this article, we explained what streams are in Java. We mentioned some of the basic methods used on streams, and focused specifically on the <code>map()</code> method and how it can be used for stream manipulation.
It is important to mention that streams are not really a mandatory part of programming, however they are more expressive and can significantly improve the readability of your code, which is why they became a common programming practice.

Mila Lukic

In this tutorial, we've gone over examples of how to use the Stream.map() method in Java 8. We've included a refresher on streams and jumped into practical examples.

Java 8 - Stream.map() Examples

<h2 id="introduction">Introduction</h2>
Currency is a very important part of our modern world. So, it's equally important for us to be able to properly express it in Java.
In this tutorial, we'll go over how to format numbers as currency Strings in Java.
<h2 id="formatnumberascurrencystring">Format Number as Currency String</h2>
Here's how you can easily format a number, such as a <code>double</code> into a currency String:
<pre><code class="hljs">double currencyAmount = 1500.00;
// Create a new Locale
Locale usa = new Locale(&quot;en&quot;, &quot;US&quot;);
// Create a Currency instance for the Locale
Currency dollars = Currency.getInstance(usa);
// Create a formatter given the Locale
NumberFormat dollarFormat = NumberFormat.getCurrencyInstance(usa);

// Format the Number into a Currency String
System.out.println(dollars.getDisplayName() + &quot;: &quot; + dollarFormat.format(currencyAmount));
</code></pre>
If we run this code, it'll result in:
<pre><code class="hljs">US Dollar: $1,500.00
</code></pre>
Formatting numbers in different currencies involves a few Java classes. Our example made use of the <code>Locale</code> and <code>Currency</code> classes from the <code>java.util</code> package. Additionally, we used the <code>NumberFormat</code> class, which can be found in the <code>java.text</code> package.
Let's dive deeper into these classes and write a method that formats our number into multiple currencies, depending on an input.
<h2 id="thelocaleclass">The Locale Class</h2>
Each <code>Locale</code> object expresses a geopolitical region and includes information such as language and location. Countries have unique ways of expressing currency. Instead of us having to manually format each currency differently, using <code>Locale</code> objects allow us to automate this process.
To create a new <code>Locale</code> object, we can use one of the three available constructors:
<pre><code class="hljs">Locale(String language);
Locale(String language, String country);
Locale(String language, String country, String variant);
</code></pre>
Do note, however, that the <code>String</code> parameters for the constructors cannot be arbitrary. You can find a full list of all supported locales in Java 8 <a href="https://www.oracle.com/java/technologies/javase/jdk8-jre8-suported-locales.html" target="_blank" rel="noopener nofollow">here</a>.
Now let's create some example <code>Locale</code> objects. We will reference these later when we are creating the actual method for printing out currency:
<pre><code class="hljs">Locale usa = new Locale(&quot;en&quot;, &quot;US&quot;);
Locale germany = new Locale(&quot;de&quot;, &quot;DE&quot;);
Locale japan = new Locale(&quot;jp&quot;, &quot;JP&quot;);
</code></pre>
Since we are working with currency, the first <code>String</code> parameter, language, will dictate the formatting of the currency value (ex. 1,000,000.00 or 1.000.000,00). The second <code>String</code> parameter, region, will determine which currency sign is used (ex. $ or ¥).
<h2 id="thecurrencyclass">The Currency Class</h2>
The second class that we need to understand is the <code>Currency</code> class. Each <code>Currency</code> object represents a world currency. We want to get a currency given our <code>Locale</code>, so we will be using the following method:
<pre><code class="hljs">Currency.getInstance(Locale locale);
</code></pre>
This will return the corresponding <code>Currency</code> instance for the specified <code>Locale</code> parameter. So, using the <code>Locale</code> objects we created previously, this is what we will do:
<pre><code class="hljs">Currency dollars = Currency.getInstance(usa);
Currency euros = Currency.getInstance(germany);
Currency yen = Currency.getInstance(japan);
</code></pre>
Now that we have created our three <code>Currency</code> instances, we can move on to our next class.
<h2 id="thenumberformatclass">The NumberFormat Class</h2>
The <code>NumberFormat</code> class has methods to format numbers based on locales. Countries have different ways of grouping numbers. For example, one thousand can be represented as &quot;1000&quot;, &quot;1,000&quot;, &quot;1 000&quot; and other variations.
We'll be using the <code>NumberFormat.getCurrencyInstance(Locale l)</code> method. This method returns a <code>NumberFormat</code> object that corresponds to the <code>Locale</code> parameter specified. This is how we'll be using it in our method:
<pre><code class="hljs">NumberFormat dollarFormat = NumberFormat.getCurrencyInstance(usa);
NumberFormat eurosFormat = NumberFormat.getCurrencyInstance(germany);
NumberFormat yenFormat = NumberFormat.getCurrencyInstance(japan);
</code></pre>
<h2 id="creatingamethodtoprintanumberasacurrency">Creating a Method to Print a Number as a Currency</h2>
Now that we have learned about the three classes needed for this program, we can start writing the actual method to print a <code>double</code> with currency formatting.
We'll also accept a String, specifying which currency we'd like to print it as:
<pre><code class="hljs">public static void printCurrency(double currencyAmount, String outputCurrency) {
 Locale locale;
 
 if (outputCurrency.equals(&quot;Yen&quot;)) {
 locale = new Locale(&quot;jp&quot;, &quot;JP&quot;);
 } else if(outputCurrency.equals(&quot;Euros&quot;)) {
 locale = new Locale(&quot;de&quot;, &quot;DE&quot;);
 } else if (outputCurrency.equals(&quot;Dollars&quot;)) {
 locale = new Locale(&quot;en&quot;, &quot;US&quot;);
 } else {
 locale = new Locale(&quot;en&quot;, &quot;US&quot;);
 }
 
 Currency currency = Currency.getInstance(locale);
 NumberFormat numberFormat = NumberFormat.getCurrencyInstance(locale);
 
 System.out.println(currency.getDisplayName() + &quot;: &quot; + numberFormat.format(currencyAmount)); 

 }
}
</code></pre>
Let's test this method out by calling it and passing in the appropriate arguments:
<pre><code class="hljs">printCurrency(1000000.00, &quot;Yen&quot;);
printCurrency(1000000.00, &quot;Dollars&quot;);
printCurrency(1000000.00, &quot;Euros&quot;);
</code></pre>
This results in:
<pre><code class="hljs">Japanese Yen: JPY 1,000,000
US Dollar: $1,000,000.00
Euro: 1.000.000,00 €
</code></pre>
For this example, we used a <code>double</code> and printed as currency with proper formatting. Other number types would work as well, but we advise to stick with <code>double</code> for currency values.
<h2 id="conclusion">Conclusion</h2>
In this article, we learned a bit about the <code>Locale</code>, <code>Currency</code>, and <code>NumberFormat</code> classes. We then applied this knowledge in a method that allowed us to correctly format and print a <code>double</code> as currency.

In this guide, you will use Java to format a number into a currency string. We use Locale, Currency and NumberFormat objects.

How to Format Number as Currency String in Java

<h2 id="introduction">Introduction</h2>
In this article we're going to be taking a look at the try/except clause, and specifically how you can catch multiple exceptions in a single line, as well as how to use the <code>suppress()</code> method.
Both of these techniques will help you in writing more accessible and versatile code that adheres to DRY (don't repeat yourself) principles.
Let's start by looking at the problem:
<pre><code class="hljs">try:
 do_the_thing()
except TypeError as e:
 do_the_other_thing()
except KeyError as e:
 do_the_other_thing()
except IndexError as e:
 do_the_other_thing()
</code></pre>
Brutal.
As we can see, this is very WET code, we repeat the same invocation multiple times. Practices like this can make our code's reading and refactoring a living nightmare.
<blockquote>
Rather than writing exceptions one after another, wouldn't it be better to group all of these exception handlers into a single line?
</blockquote>
<h2 id="multipleexceptions">Multiple Exceptions</h2>
If you're just here for a quick answer, it's simple: use a tuple.
All the errors contained in the exception line tuple will be evaluated together:
<pre><code class="hljs">try:
 do_the_thing()
except (TypeError, KeyError, IndexError) as e:
 do_the_other_thing()
</code></pre>
Easy, right?
<h2 id="avoidingbadpractices">Avoiding Bad Practices</h2>
<blockquote>
&quot;Errors should never pass silently.&quot; - <a rel="nofollow noopener" target="_blank" href="https://www.python.org/dev/peps/pep-0020/#:~:text=Errors%20should%20never%20pass%20silently,obvious%20way%20to%20do%20it.">The Zen of Python</a>.
</blockquote>
try/except clauses are probably the most misused pattern in Python.
Used improperly, they end up being the cliché of drunks and lampposts, being used only when the Python interpreter starts caroling the &quot;12 Errors of Christmas&quot;.
It's very tempting to just put a <code>try</code> and a bare exception on a problem to &quot;make it go away&quot;. By doing that, we're effectively sweeping the exceptions under the rug, which is a shame, especially since they can be wonderfully helpful in recovering from potentially fatal errors, or shining a light on hidden bugs.
That's why when using except clauses you should always be sure to specify the errors you know you could encounter, and exclude the ones you don't.
Letting your program fail is okay, even preferred, to just pretending the problem doesn't exist.
<blockquote>
&quot;Errors should never pass silently... unless explicitly silenced.&quot;
</blockquote>
However, once in a blue moon when you do get the opportunity to ignore exception handling, you can use <code>suppress()</code>:
<pre><code class="hljs">from contextlib import suppress

with suppress(TypeError, KeyError, IndexError):
 do_the_thing()
</code></pre>
The <code>suppress()</code> method takes a number of exceptions as its argument, and performs a try/except/pass with those errors. As you can see it also lets you write multiple exceptions in a single line.
This let's you avoid writing a try/except/pass manually:
<pre><code class="hljs">try:
 do_the_thing()
except (TypeError, KeyError, IndexError) as e:
 pass
</code></pre>
Better yet, it's also standard in any version of Python 3.4 and above!
<h2 id="conclusion">Conclusion</h2>
In this article, we've covered how to handle multiple exceptions in a single line. We've also briefly gone over some bad practices of ignoring exceptions, and used the <code>suppress()</code> function to suppress exceptions explicitly.

Spencer Porter

In this article, we've gone over how to catch multiple exceptions in one line in Python, with code examples. We've also covered some bad practices and how to avoid them.

Python: Catch Multiple Exceptions in One Line

<h2 id="introduction">Introduction</h2>
In this article, we'll take a look at how to check if a String starts with another String in Java.
This is is a fairly common task in programming, and is very similar to <a target="_blank" href="/java-check-if-string-contains-a-substring/">checking if a string contains a substring</a>. For example, this can come in useful if we want to filter out all of the words out of a huge selection starting with a specific String.
However, this problem differs from checking if a String only contains a specific substring, and there's a few ways to do so in both Core Java and Apache Commons:
<ul>
<li><a href="#stringstartswith">String.startsWith()</a></li>
<li><a href="#streamanymatch">Stream.anyMatch()</a></li>
<li><a href="#stringindexof">String.indexOf()</a></li>
<li><a href="#patternwithregexandmatcher">Pattern with Regex</a></li>
<li><a href="#usingaforloop">Using a for-loop</a></li>
<li><a href="#stringutilsindexof">StringUtils.indexOf()</a></li>
<li><a href="#stringutilsstartswith">StringUtils.startsWith()</a></li>
<li><a href="#stringutilsstartswithany">StringUtils.startsWithAny()</a></li>
<li><a href="#stringutilsstartswithignorecase">StringUtils.startsWithIgnoreCase()</a></li>
</ul>
<h2 id="corejava">Core Java</h2>
Let's start off with solutions that can easily be implemented using Core Java.
<h3 id="stringstartswith">String.startsWith()</h3>
This method does exactly what we need it to do - and is the most common way to solve this problem. It returns a <code>boolean</code>, which indicates if the string begins with the provided keyword:
<pre><code class="hljs">String string = &quot;every end is a new beginning&quot;;

System.out.println(string.toLowerCase().startsWith(&quot;new&quot;.toLowerCase()));
System.out.println(string.toLowerCase().startsWith(&quot;EVERY&quot;.toLowerCase()));
System.out.println(string.toLowerCase().startsWith(&quot;&quot;));
</code></pre>
Running this outputs:
<pre><code class="hljs">false
true
true
</code></pre>
Note: If the parameter passed is an empty string, the result is always <code>true</code>.
Of course, this method is case-sensitive, and should always be used in pair with <code>toLowerCase()</code> or <code>toUpperCase()</code> when we're just looking for a specific keyword and don't care if the cases match.
<h3 id="streamanymatch">Stream.anyMatch()</h3>
Another thing we could check for is if a String starts with multiple substrings. Say, we have a few standardized prefixes - we can use make a <code>Stream</code> of substrings, and run an <code>anyMatch()</code> check for the String we're checking in.
Let's take a look at how to do that:
<pre><code class="hljs">String string = &quot;every end is a new beginning&quot;;
System.out.println(Stream.of(&quot;every&quot;, &quot;none&quot;).anyMatch(string::startsWith));
</code></pre>
Here, we've created a <code>Stream</code> of possible substrings, and checked if any of them are present at the start of the given String with a method reference call to <code>startsWith()</code>.
This code results in:
<pre><code class="hljs">true
</code></pre>
<h3 id="stringindexof">String.indexOf()</h3>
The <code>indexOf()</code> method can be quite useful in solving a variety of problems concerning substrings, including checking if a string begins with a specific one.
The method returns the index of the first occurrence of a substring within a string if it's found, otherwise <code>-1</code>.
It has a few overloaded variants from which we'll only be needing just the one below, since the other ones have different appliances:
<pre><code class="hljs">public int indexOf(String str)
</code></pre>
If the <code>indexOf()</code> method returns <code>0</code>, that means our String begins with another we've given it as a parameter.
For example:
<pre><code class="hljs">String string = &quot;Just a sample String&quot;;

System.out.println(string.toLowerCase().indexOf(&quot;just&quot;.toLowerCase()));
System.out.println(string.toLowerCase().indexOf(&quot;String&quot;.toLowerCase()));
System.out.println(string.toLowerCase().indexOf(&quot;something else&quot;.toLowerCase()));
</code></pre>
will output:
<pre><code class="hljs">0
14
-1
</code></pre>
<ul>
<li>The answer we're looking for is found within our first example, as it returned <code>0</code> - exactly what we need, meaning our string begins with a given parameter.</li>
<li>We can clearly see that in the second example, the <code>&quot;String&quot;</code> parameter we've given is indeed found within our String, but at the position <code>14</code>, which is not what we were looking for.</li>
<li>The third example isn't even contained within our String, and returns <code>-1</code>.</li>
</ul>
Using the information above, we can accumulate the logic in a function:
<pre><code class="hljs">public static boolean startsWithSubstring(String text, String keyword) {
 return text.toLowerCase().indexOf(keyword.toLowerCase()) == 0;
}
</code></pre>
<h3 id="patternwithregexandmatcher">Pattern with Regex and Matcher</h3>
The <code>Pattern</code> class is a compiled representation of a regular expression. With this <code>Pattern</code> we can then generate an engine that recognizes said regular expression - we can generate a <code>Matcher</code>.
We'll be using the <code>find()</code> method in combination with <code>start()</code> to check if our <code>Matcher</code> instance begins with a given String:
<pre><code class="hljs">public static boolean startsWithSubstring(String text, String keyword) {
 String inputString = text.toLowerCase();
 String subString = keyword.toLowerCase();


 // We compile the regular expression to generate a Pattern object
 Pattern pattern = Pattern.compile(subString);

 // Then we generate an engine (Matcher) which can be used
 // to recognize and match the regular expression it was
 // generated from (in our case &quot;this&quot;).
 Matcher matcher = pattern.matcher(inputString);

 // find() compares the assigned and compiled patterns, and will return a boolean value indicating if they match.
 // That&#x27;s where the start() method comes into play; it returns the index of the position 
 // where the two strings matched, or -1 if it&#x27;s not found.
 if (matcher.find()) {
 return matcher.start() == 0;
 }
 return false;
}
</code></pre>
Let's test this method out:
<pre><code class="hljs">System.out.println(startsWithSubstring(string, &quot;every&quot;));
</code></pre>
This results in:
<pre><code class="hljs">true
</code></pre>
<h3 id="usingaforloop">Using a for-loop</h3>
A more low-level way of solving this problem would be using a for-loop.
We iterate through the whole length of the search string, we compare the first <code>searchString.length()</code> characters and return <code>true</code> if the all match.
Let's see how this all works in code:
<pre><code class="hljs">public static boolean startsWithSubstring(String text, String keyword) {
 for (int i = 0; i &lt; keyword.length(); i++) {
 if (text.toLowerCase().charAt(i) != keyword.toLowerCase().charAt(i)) {
 System.out.println(&quot;String doesn&#x27;t start with &quot; + &quot;\&quot;&quot; + keyword + &quot;\&quot;&quot;);
 return false;
 } else if (i == keyword.length() - 1) {
 System.out.println(&quot;String starts with &quot; + &quot;\&quot;&quot; + keyword + &quot;\&quot;&quot;);
 return true;
 }
 }
 return false;
}
</code></pre>
Let's test this method out:
<pre><code class="hljs">String string = &quot;Just a sample String&quot;;

System.out.println(startsWithSubstring(string, &quot;just&quot;));
System.out.println(startsWithSubstring(string, &quot;String&quot;));
System.out.println(startsWithSubstring(string, &quot;something else&quot;));
</code></pre>
This results in:
<pre><code class="hljs">String starts with &quot;just&quot;
true
String doesn&#x27;t start with &quot;String&quot;
false
String doesn&#x27;t start with &quot;something else&quot;
false
</code></pre>
By default, if we hadn't used <code>toLowerCase()</code> to even out the letters in the method itself, this approach would've been case-sensitive.
<h2 id="apachecommons">Apache Commons</h2>
The <a rel="nofollow noopener" target="_blank" href="https://commons.apache.org/">Apache Commons</a> library provides functionality that expands on the core Java Framework. It's one of the top third-party libraries and is present in many modern Java projects.
Apache Commons offers the <code>StringUtils</code> class, which contains many methods used to manipulate strings. Most of these methods are quite similar to the ones found in <code>java.lang.String</code>. The main difference being that all methods within the <code>StringUtils</code> class are null-safe.
However, for this task we'll need only a few methods from this class:
<ol>
<li><code>.indexOf()</code></li>
<li><code>.startsWith()</code></li>
<li><code>.startsWithIgnoreCase()</code>.</li>
</ol>
If not already, include the Apache Commons library in your project by adding a dependency to your <code>pom.xml</code> file if you're using Maven:
<pre><code class="hljs">&lt;dependency&gt;
 &lt;groupId&gt;org.apache.commons&lt;/groupId&gt;
 &lt;artifactId&gt;commons-lang3&lt;/artifactId&gt;
 &lt;version&gt;3.11&lt;/version&gt;
&lt;/dependency&gt;
</code></pre>
Or by adding it to Gradle:
<pre><code class="hljs">compile group: &#x27;org.apache.commons&#x27;, name: &#x27;commons-lang3&#x27;, version: &#x27;3.11&#x27;
</code></pre>
<h3 id="stringutilsindexof">StringUtils.indexOf()</h3>
This method has a few overloaded variants all of which return an <code>int</code> value indicating the index of the first occurrence of the substring, or <code>-1</code> if the substring doesn't appear at all.
We'll be focusing on the following variant of this method:
<pre><code class="hljs">public static int indexOf(CharSequence seq, CharSequence searchSeq)
</code></pre>
This method takes two <code>String</code>s/<code>CharSequence</code>s.
The <code>seq</code> parameter represents the String we'll be searching through to find <code>searchSeq</code>. Same logic applies as before - if this function returns <code>0</code>, we'll know that our string begins with a given <code>searchSeq</code> substring.
Also keep in mind that this method, like its counterpart, is also case-sensitive, so using <code>.toLowerCase()</code> or <code>.toUpperCase()</code> is required to achieve a case-insensitive behavior.
Using this method is very similar to using the <code>indexOf()</code> from <code>java.lang.String</code>:
<pre><code class="hljs">String string = &quot;a simple string to search in&quot;;

System.out.println(StringUtils.indexOf(string.toLowerCase(), &quot;a simple&quot;.toLowerCase()));
System.out.println(StringUtils.indexOf(string.toLowerCase(), &quot;string&quot;.toLowerCase()));
System.out.println(StringUtils.indexOf(string.toLowerCase(), &quot;something&quot;.toLowerCase()));
</code></pre>
This will yield:
<pre><code class="hljs">0
9
-1
</code></pre>
And thus, we can use this as a convenience method:
<pre><code class="hljs">public static boolean startsWithSubstring(String text, String keyword) {
 return StringUtils.indexOf(text.toLowerCase(), keyword.toLowerCase()) == 0;
}
</code></pre>
<h3 id="stringutilsstartswith">StringUtils.startsWith()</h3>
This method does exactly what you'd expect. It's also case-sensitive like it's predecessors, and accepts the same two parameters.
It returns <code>true</code> if the <code>text</code> begins with the <code>keyword</code>, or <code>false</code> if it doesn't.
Comparing two <code>null</code> values will result in <code>true</code>:
<pre><code class="hljs">String string = &quot;a simple string to search in&quot;;

System.out.println(StringUtils.startsWith(string.toLowerCase(), &quot;A SIMPLE&quot;));
System.out.println(StringUtils.startsWith(string.toLowerCase(), &quot;A SIMPLE&quot;.toLowerCase()));
System.out.println(StringUtils.startsWith(null, null));
</code></pre>
Running this will output:
<pre><code class="hljs">false
true
true
</code></pre>
<h3 id="stringutilsstartswithany">StringUtils.startsWithAny()</h3>
The <code>startsWithAny()</code> doesn't have a counterpart in the <code>java.lang.String</code> class, and is unique to <code>StringUtils</code>.
However, it is very close to what we did with <code>anyMatch()</code> on a Stream - It checks if a <code>String</code> begins with any of the given substrings, returning <code>true</code> or <code>false</code> appropriately.
It's also case-sensitive:
<pre><code class="hljs">String string = &quot;a simple string to search in&quot;;

System.out.println(StringUtils.startsWithAny(string, &quot;something&quot;, &quot;a simple&quot;));
System.out.println(StringUtils.startsWithAny(string, &quot;something&quot;, &quot;string&quot;));
System.out.println(StringUtils.startsWithAny(string, &quot;something&quot;, null));
System.out.println(StringUtils.startsWithAny(string, &quot;something&quot;, &quot;&quot;));
</code></pre>
Running this gives us:
<pre><code class="hljs">true
false
false
true
</code></pre>
<h3 id="stringutilsstartswithignorecase">StringUtils.startsWithIgnoreCase()</h3>
Since it can get annoying to call <code>toLowerCase()</code> all the time on Strings during comparison, you can alternatively sue the <code>startsWithIgnoreCase()</code> method.
Like the <code>startsWith()</code> method from the same class, it takes two Strings (or <code>CharSequence</code>) types, and the return value is <code>true</code> or <code>false</code> depending on if the text actually starts with the provided keyword:
<pre><code class="hljs">String string = &quot;a simple string to search in&quot;;

System.out.println(StringUtils.startsWithIgnoreCase(string, &quot;something&quot;));
System.out.println(StringUtils.startsWithIgnoreCase(string, &quot;A SIMPLE&quot;));
System.out.println(StringUtils.startsWithIgnoreCase(string, &quot;&quot;));
System.out.println(StringUtils.startsWithIgnoreCase(string, null));
</code></pre>
Running this outputs:
<pre><code class="hljs">false
true
true
false
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this article, we've gone over all the different method of checking if a <code>String</code> begins with another <code>String</code>, both in core Java and utilizing the Apache Commons library.
In conclusion, there are many different ways to accomplish this task. In reality, we could have combined any of the methods above in order to find an index that a substring starts on, and from there on check where the substring is positioned at.
Most of the time, just using the <code>startsWith()</code> methods, or <code>startsWithIgnoreCase()</code> would be enough to solve this problem and would also give the cleanest, shortest code.

Branko Ilic

In this tutorial, we'll go over examples of how to check if a String starts with a substring in Java. We'll cover Core Java as well as Apache Commons methods.

Java: Check if String Starts with Another String

<h2 id="introduction">Introduction</h2>
When managing a computer, we may want to automate some tasks to run in certain periods or at the same time on each day/week/month. On a desktop, we may schedule update checks or virus scans. On a server, it's not uncommon for a myriad of checks and clean up routines to be scheduled to ensure applications are running optimally.
In this article, we will look at the <code>cron</code> program. This utility is a task scheduler for Unix-like systems. After going over cron basics, we'll look at the <code>crontab</code> command to manage our scheduled tasks.
<h2 id="whatiscronwhatisacrontab">What is Cron? What is a Crontab?</h2>
To master <code>cron</code> and scheduling, it helps to have a grasp of various but similar terminology used.
Cron is the program that schedules scripts or commands to run at user-specified times. A cron expression is a string that details the schedule to trigger a command. A cron table is a configuration file containing the shell commands in each line preceded by a cron expression.
Here's an image with a system crontab that references two external scripts:
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-use-the-crontab-command-in-unix-1.png" alt="Editing the crontabs directly">
Generally, cron tables look like this:
<pre><code class="hljs">&lt;cron-expression&gt; &lt;command&gt;
&lt;cron-expression&gt; &lt;command&gt;
</code></pre>
When your computer first starts up, cron searches for all crontabs in system-configured directories. The directory varies from OS to OS but it's typically <code>/etc/crontab</code> for special system-wide crontabs and a local directory for the user who's logged in. These are both loaded into memory.
The cron program wakes up every minute and checks the crontab in memory to see if any commands need to be run at the current minute. It executes all scheduled commands and sleeps again.
There are two methods by which the cron jobs can be scheduled:
<ol>
<li>Edit the <code>crontab</code> directly</li>
</ol>
We can view the cron jobs we have scheduled by running this command:
<pre><code class="hljs">$ crontab -l
</code></pre>
If we would like to add or edit a cron job, we can then use this command:
<pre><code class="hljs">$ crontab -e
</code></pre>
This is the preferred method to edit crontabs because it selects the user crontab and not the system one, and it also catches syntax errors.
<ol start="2">
<li>Copying the scripts to the <code>/etc/cron.*</code> directories</li>
</ol>
If scheduling the scripts for accurate time slots is not required, the scripts can also be moved inside certain pre-built cron schedule folders, for the crontab to pick them up for execution. These predefined directories that act as placeholders include:
<table class="table table-striped" style="font-size:15px;overflow-x:auto;">
<thead>
 <tr>
 <th>Location</th>
 <th>Execution Schedule</th>
 </tr>
</thead>
<tbody>
 <tr>
 <td>/etc/cron.hourly/</td>
 <td>Once every hour</td>
 </tr>
 <tr>
 <td>/etc/cron.daily/</td>
 <td>Once per day, everyday</td>
 </tr>
 <tr>
 <td>/etc/cron.monthly/</td>
 <td>Once per month, every month</td>
 </tr>
 <tr>
 <td>/etc/cron.weekly/</td>
 <td>Once per week, every week</td>
 </tr>
</tbody>
</table>
The users can copy their scripts to the appropriate directories depending on which frequency they need to be run. The crontab file present in <code>/etc/crontab</code> contains the cron expressions defined for each directory and it checks every minute if the time is right for the scripts are to be executed:
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-use-the-crontab-command-in-unix-2.png" alt="Copying scripts to the corresponding /etc/cron.* directories">
Note that scripts placed in these special folders are system-wide cron jobs and not user-specific ones.
<h2 id="creatingacronexpression">Creating a Cron Expression</h2>
Each entry of the crontab contains a cron expression, a user name, and the command to be executed separated with white spaces or tabs:
<pre><code class="hljs"> * * * * * user-name command-or-file-to-be-executed
# &lt;-----------&gt; &lt;-------&gt; &lt;----------------------------&gt;
# Cron
# Expression
</code></pre>
Note: The <code>user-name</code> column is used when editing the system-wide crontab. A user-specific crontab does not need it because that info is already known.
The 5 asterisks (<code>* * * * *</code>) in the cron expression can be substituted with numbers. Their positions indicate their value:
<table class="table table-striped" style="font-size:15px;overflow-x:auto;">
<thead>
 <tr>
 <th>* Position</th>
 <th>Description</th>
 <th>Allowed numeric values</th>
 </tr>
</thead>
<tbody>
 <tr>
 <td>1</td>
 <td>Minute</td>
 <td>0-59</td>
 </tr>
 <tr>
 <td>2</td>
 <td>Hour</td>
 <td>0-23</td>
 </tr>
 <tr>
 <td>3</td>
 <td>Day of Month</td>
 <td>1-31</td>
 </tr>
 <tr>
 <td>4</td>
 <td>Month</td>
 <td>0-12</td>
 </tr>
 <tr>
 <td>5</td>
 <td>Day of Week [0 represents Sunday & Saturday represents 6]</td>
 <td>0-6</td>
 </tr>
</tbody>
</table>
Alongside numbers, there are special characters we can use when editing a crontab:
<table class="table table-striped" style="font-size:15px;overflow-x:auto;">
<thead>
 <tr>
 <th>Characters</th>
 <th>Description</th>
 </tr>
</thead>
<tbody>
 <tr>
 <td>*</td>
 <td>Defining this will run the command for each time frame. For example, * defined under the minute column, will execute the script every minute</td>
 </tr>
 <tr>
 <td>,</td>
 <td>To repeat a task in multiple different time frames, commas can be used. For example, to run a script every 10 minutes, the minute column can be given as 0,10,20,30,40,50</td>
 </tr>
 <tr>
 <td>/</td>
 <td>An alternative, simpler version of ",". To run a script every 10 minutes, the minute column can be given as */10</td>
 </tr>
 <tr>
 <td>-</td>
 <td>Specifies a range of values. To run a script every minute for the first 10 minutes, the expression in the minute column can be given as: 0-10</td>
 </tr>
</tbody>
</table>
That's a lot of options to understand, it might be best to show how they work with some examples:
<ol>
<li>Here's how to run <code>echo &quot;hello there!&quot;</code> on the &quot;4th day of every week&quot; (i.e. on Thursday) at 12:10 hours:</li>
</ol>
<pre><code class="hljs">10 12 * * 4 root echo &quot;hello there!&quot;
</code></pre>
<ol start="2">
<li>And here's a more complicated example where we save disk usage every 20 minutes on the first 10 days of the last three months of the year:</li>
</ol>
<pre><code class="hljs">*/20 * 1-10 10,11,12 * df -h &gt;&gt; /tmp/diskusage
</code></pre>
Cron expressions can be overwhelming at first sight. There are numerous tools available online to simplify the creation of expressions; <code>crontab.guru</code> is one of the widely popular tools available online at <a href="https://crontab.guru/" rel="nofollow noopener" target="_blank">crontab.guru/</a>.
Let's use crontab.guru to check if our second express is valid: <a href="https://crontab.guru/#*/20_*_1-10_10,11,12_*" rel="nofollow noopener" target="_blank">crontab.guru/#*/20_*_1-10_10,11,12_*</a>.
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-use-the-crontab-command-in-unix-3.png" alt="Copying scripts to the corresponding /etc/cron.* directories">
<h2 id="handsonguidecreatingacronjobtoemaildiskandmemoryusage">Hands-on Guide: Creating a Cron Job to Email Disk and Memory Usage</h2>
In an IT department, system administrators and other operators frequently monitor computer resources such as memory and disk size. Crontab is commonly used to ensure monitoring scripts are run continuously.
We are going to create a cron job that monitors disk and RAM usage using <a href="https://github.com/datawrangl3r/watchmon" rel="nofollow noopener" target="_blank">Watchmon</a>. If either metric is above a certain threshold, we will get an email to alert us. We'll put this script in a cron job that runs every minute.
The following demo was tested on <code>Ubuntu 20.04.1 LTS</code>. This example is configured to send an email to a Gmail account, you may need to tweak your configurations for other email providers.
<ul>
<li>You first need to install watchmon. Follow their <a href="https://github.com/datawrangl3r/watchmon" rel="nofollow noopener" target="_blank">README</a> to learn how to set it up:</li>
</ul>
<pre><code class="hljs">$ git clone https://github.com/datawrangl3r/watchmon
$ cd watchmon
$ bash setup.sh
</code></pre>
<ul>
<li>The script will start the cron process, install <a a href="http://www.mutt.org/" rel="nofollow noopener" target="_blank">http://www.mutt.org/</a>, a command-line SMTP client, to send emails. Once installed, use your text editor to the <code>mutt.rc</code> file in your home directory: <code>/home/user/mutt/mutt.rc</code>.</li>
</ul>
Edit your file so it looks like this, changing the template data with your email:
<pre><code class="hljs">set ssl_starttls=yes
set ssl_force_tls=yes

set imap_user = &quot;change_this_user_name@gmail.com&quot;
set imap_pass = &quot;PASSWORD&quot;

set from=&quot;change_this_user_name@gmail.com&quot;
set realname=&quot;Your Name&quot;

set folder = &quot;imaps://imap.gmail.com/&quot;
set spoolfile = &quot;imaps://imap.gmail.com/INBOX&quot;
set postponed=&quot;imaps://imap.gmail.com/[Gmail]/Drafts&quot;

set header_cache = &quot;~/.mutt/cache/headers&quot;
set message_cachedir = &quot;~/.mutt/cache/bodies&quot;
set certificate_file = &quot;~/.mutt/certificates&quot;

set smtp_url = &quot;smtps://change_this_user_name@gmail.com:PASSWORD@smtp.gmail.com:465/&quot;

set move = no
set imap_keepalive = 900
</code></pre>
<ul>
<li>Since Google doesn't allow its services to be accessible by less secure apps, we need to enable access for the email account to be used in the SMTP settings. Visit <a a href="https://myaccount.google.com/security" rel="nofollow noopener" target="_blank">https://myaccount.google.com/security</a>, and toggle the less secure app access to ON, as shown in the gif below:</li>
</ul>
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-use-the-crontab-command-in-unix-4.gif" alt="Allowing access to the less secure apps on gmail">
<ul>
<li>Now that our scripts and email account configurations are ready, we can set up our crontab. Edit your crontab by invoking:</li>
</ul>
<pre><code class="hljs">$ crontab -e
</code></pre>
Now enter the corresponding cron expression and path to the executable with arguments. Note that the path on your machine will differ from what is shown below:
<pre><code class="hljs">* * * * * /mnt/c/Users/sathy/Documents/datawrangler/watchmon/watchmon.sh -t=40 -e=sathyasarathi90@gmail.com
</code></pre>
This can be configured as shown below:
<img src="https://stackabuse.s3.amazonaws.com/media/how-to-use-the-crontab-command-in-unix-5.gif" alt="Figure 5: Allowing access to the less secure apps on gmail">
The cron utility makes sure to execute the script every minute and as a result, an email is sent from the machine to the recipients until the disk space or memory of the machine is cleared.
<h2 id="cronjobsanddealingwithfailures">Cron Jobs and Dealing with Failures</h2>
Although crontabs are very powerful, they can't alert the user if an underlying job is not triggered or the scheduled executable encounters an error. The logs for each job run can be found in the <code>/var/log/syslog</code> file. Be sure to review your logs after activities are scheduled.
Aside from cron and command errors, many crontabs are plagued by human errors. When setting up cron jobs, here are some common reasons why your cron job may not run as you'd expect it to:
<ul>
<li>
The scripts don't have the execute permission for it. Those executables that are to be run as cron jobs should have the permission as <code>755</code> i.e. <code>rwx-rw-rw</code>. The cron utility can only execute scripts if the user has executable permissions for it.
</li>
<li>
The crontab is syntactically correct but the wrong path was used for the jobs. It's important to specify the absolute path to the executable and the command itself. Relative paths need to be avoided at all costs.
</li>
<li>
The command or script is not being run with the necessary environment variables to work. In these cases, make sure that the script you run can set up the required env vars when running as a cron job.
</li>
</ul>
<h2 id="conclusion">Conclusion</h2>
In this article, we have looked at the cron program, cron expressions, and crontabs. We used the <code>crontab</code> command to list and edit cron jobs. Crontabs are some of the best tools for Unix-like systems to automate repetitive tasks. What would you schedule with a cron job?

Marcus Sanatan

Sathiya Sarathi Gunasekaran

Cron jobs are scheduled activities in Unix-like systems. In this article, you will use the crontab command to add and manage cron jobs on Linux.

How to Use the Crontab Command in Unix

How to Use the crontab Command in Unix

Kristina Popovic

In this guide, we'll go over all you need to know to do Data Visualization in Python with Pandas - Bar Charts, Histograms, Area Plots, Pie Charts, Density Plots and Scatter Matrices.

Introduction to Data Visualization in Python with Pandas

Guide to Data Visualization in Python with Pandas

<h2 id="introduction">Introduction</h2>
One of the biggest challenges the developers are facing is being Agile or, in other words, being able to deliver stable releases of the products on time. With every Sprint, we need to deliver new features, bug-free features.
And why bother with building, testing, and deploying manually when we could have an automated process? A process that would check every piece of code before merging it in the stable branch and then deploying it. For example, deploying it on a testing machine ready for the QA team.
There are many tools for implementing this CI/CD process, but we'll stick with an awesome open-source tool, Jenkins.
Jenkins is an automation server. It helps automate building, testing, and deploying your application. Jenkins supports Git and Maven which will be our guest stars in this mini project.
This article will guide you through configuring the Jenkins process to be triggered every time a commit is made. Then we'll make sure our GitHub repository is configured properly for this scenario. Lastly, we will make a small test to show that everything works properly.
<h2 id="prerequisites">Prerequisites</h2>
For you to be able to follow this tutorial, some small things need to be set up.
<ul>
<li>A Jenkins server. You can use DigitalOcean to create a droplet with Jenkins ready to use. It should take less than 5 minutes.</li>
<li>A GitHub repository. Note that you can use and source control hosting provider as long as they provide you the ability to add Webhooks.</li>
<li>A Spring Boot application with tests. If you don't have one already you can clone <a rel="nofollow noopener" target="_blank" href="https://github.com/alexchirea/SimpleSpringBootApp">this</a> repository.</li>
</ul>
<h2 id="configuringjenkins">Configuring Jenkins</h2>
So after you created the Jenkins droplet, there are some steps you need to follow for the machine to be up and running.
Let's connect to our newly created droplet and prepare our environment. We'll start by running some commands in the terminal:
<pre><code class="hljs">$ ssh root@YOUR_VM_IP
</code></pre>
You will be asked to create your Jenkins password. Use a strong password and restart your Jenkins service:
<pre><code class="hljs">$ systemctl restart jenkins
</code></pre>
Your Jenkins server is now accessible at the following address <code>http://YOUR_VM_IP:8080</code> and you should see something like this. After that, you'll be redirected to the login page:
<img src="https://stackabuse.s3.amazonaws.com/media/set-up-gated-checkin-for-spring-boot-projects-with-github-and-jenkins-1.png" alt="jenkins loading screen">
And voilà, we are ready!
<img src="https://stackabuse.s3.amazonaws.com/media/set-up-gated-checkin-for-spring-boot-projects-with-github-and-jenkins-2.png" alt="jenkins login page">
The default username is <code>admin</code>, and the password is the one you created at the beginning.
Before we create our first project, let's go to Manage Jenkins ~&gt; Manage Plugins and install GitHub Pull Request Builder.
Now go to Manage Jenkins ~&gt; Configure System set up the GitHub server. Let's go and click on New Item in the upper left corner of the screen:
<img src="https://stackabuse.s3.amazonaws.com/media/set-up-gated-checkin-for-spring-boot-projects-with-github-and-jenkins-3.png" alt="click on new item jenkins">
Now, go ahead and type a name for your new project and select Freestyle project:
<img src="https://stackabuse.s3.amazonaws.com/media/set-up-gated-checkin-for-spring-boot-projects-with-github-and-jenkins-4.png" alt="create a new freestyle project jenkins">
We need to specify some parameters for the project, so Jenkins will know what commit it should use for the build and test part.
The first thing we need to do is to specify the project URL, under the General tab, and GitHub project.
Under Source Code Management tab, select Git. After you enter your Repository URL and your credentials, under Branched to build, use <code>${ghprbActualCommit}</code>.
Click on the Advanced... button and add the following details:
<ul>
<li>Name: <code>origin</code></li>
<li>Refspec: <code>+refs/pull/${ghprbPullId}/*:refs/remotes/origin/pr/${ghprbPullId}/*</code></li>
</ul>
Note: This value is required in order to build only the pull requests.
<img src="https://stackabuse.s3.amazonaws.com/media/set-up-gated-checkin-for-spring-boot-projects-with-github-and-jenkins-5.png" alt="source code management jenkins">
After we have configured our repository, we need to specify when this job will be triggered. For that, go to Build Triggers tab and select GitHub Pull Request Builder.
Firstly, select the credentials configured earlier and check Use GitHub Hooks for build triggering. Now, add a Update commit status during build trigger and configure it like in the image:
<img src="https://stackabuse.s3.amazonaws.com/media/set-up-gated-checkin-for-spring-boot-projects-with-github-and-jenkins-6.png" alt="commit status update during jenkins build">
Add a Build Status Messages trigger for <code>SUCCESS</code>, <code>ERROR</code>, and <code>FAILURE</code>.
For the Build phase we'll add Invoke top-level Maven targets with the following settings:
<ul>
<li>Maven version - your desired Maven version, can be configured from System Configuration</li>
<li>Goals - <code>clean install -U</code></li>
<li>POM - <code>pom.xml</code></li>
</ul>
Click Save and we are done!
<h2 id="githubrepositoryconfiguration">GitHub Repository Configuration</h2>
We've managed so far to configure the Jenkins workflow, but what about GitHub? That's what we're going to do right now.
Go to Settings on your repository page and select the Webhooks option from the left menu. Add a new webhook with the following details:
For the Payload URL type <code>http://YOUR_VM_IP:8080/ghprbhook/</code> and we'll select Pull Requests as the triggering option. The content type should be <code>application/json</code>. Leave the Secret field empty and Save.
<h2 id="testingtheworkflow">Testing the Workflow</h2>
The moment we've been waiting for. Create a new branch, push it to GitHub, and then create a Pull Request. As soon as we create the Pull Request, a job will be triggered on Jenkins:
<img src="https://stackabuse.s3.amazonaws.com/media/set-up-gated-checkin-for-spring-boot-projects-with-github-and-jenkins-7.png" alt="github pull request jenkins">
Soon, a Details link will appear on the pull request's page. If you click on the link, you'll see a page like the this one:
<img src="https://stackabuse.s3.amazonaws.com/media/set-up-gated-checkin-for-spring-boot-projects-with-github-and-jenkins-8.png" alt="jenkins job triggered">
Now if we go to the Console Output we can see that all the tests have passed:
<pre><code class="hljs">[INFO] Tests run: 3, Failures: 0, Errors: 0, Skipped: 0
...
Finished: SUCCESS
</code></pre>
<img src="https://stackabuse.s3.amazonaws.com/media/set-up-gated-checkin-for-spring-boot-projects-with-github-and-jenkins-9.png" alt="success build jenkins">
For the sake of this tutorial, I'll make another commit with a failing test to see that it works properly. And the result:
<pre><code class="hljs">[ERROR] Tests run: 3, Failures: 1, Errors: 0, Skipped: 0
...
Finished: FAILURE
</code></pre>
<img src="https://stackabuse.s3.amazonaws.com/media/set-up-gated-checkin-for-spring-boot-projects-with-github-and-jenkins-19.png" alt="failing build jenkins">
Here, we've successfully implemented a gated check-in for Spring Boot projects, using GitHub and Jenkins.
<h2 id="conclusion">Conclusion</h2>
Software Engineers are expected to provide bug-free solutions to their clients. With complex logic, it becomes paramount to test software and ensure checks and test cases to make sure that the project is stable.
In this article, we've implemented a gated check-in for Spring Boot projects, using GitHub and Jenkins, to ensure passing checks in the code we push.

In this tutorial, we'll implement a gated check-in for Spring Boot Projects using GitHub and Jenkins to ensure passing checks for each GitHub commit/pull request.