Author: Abhinav Singh

Welcome back to the Scala tutorial.

This post is the continuation of A Simple Tutorial on Scala – Part – 1

In the Part-1 we learned the following topics on Scala

• Scala Features
• Variables and Methods
• Condition and Loops
• Variables and Type Inference
• Classes and Objects

Keeping up the same pace, we will learn the following topics in the 2nd part of the Scala series.

• Functions Representation
• Collections
• Sequence and Sets
• Tuples and Maps
• Higher Order Functions
• Build Tool – SBT

Functions Representation

We have already discussed functions. We can write a function in different styles in Scala. The first style is the usual way of defining a function.

scala> def add(x : int, y : int) : Int = {
         return x + y
       }

Please note that the return type is specified as Int.

In the second style, please note that the return type is omitted, also there is no “return” keyword. The Scala compiler will infer the return type of the function in this case.

scala> def add(x : int, y : int) = { //return type is inferred
         x + y //"return" keyword is optional
       }

If the function body has just one statement, then the curly braces are optional. In the third style, please note that there are no curly braces.

def add(x : Int, y : Int) = x + y

Continue reading “A Simple Tutorial on Scala – Part – 2”

Welcome to the Scala tutorial. We will cover the Scala in two-part blog series. In this part, we will learn the following topics

• Scala Features
• Variables and Methods
• Condition and Loops
• Variables and Type Inference
• Classes and Objects

For better understanding, do hands-on with this tutorial. We’ve made this post in such a way that the reader will find easy to follow the tutorial with hands-on.

Scala Features

Scala is a modern multi-paradigm programming language designed to express common programming patterns in a concise, elegant, and type-safe way.

It is a statically typed language. Which means it does type checking at compile-time as opposed to run-time. Let me give you an example to better understand this concept.

When we deploy jobs which will run for hours in production, we do not want to discover midway that the code has unexpected runtime errors. With Scala, you can be sure that your code will not give you unexpected errors while running in production.

Since Scala is statically typed we get performance and speed over dynamic languages.

How is Scala different than Java?

Unlike Java, in Scala, we do not have to write quite as much code to perform simple tasks and its syntax is very similar to other data-centric languages. You could say that Scala is the modified version of Java with less boilerplate code.

Continue reading “A Simple Tutorial on Scala – Part – 1”

This post is the continuation of A Simple Tutorial on Linux – Part-1

In the Part-1 we learned the following topics on Linux.

• Linux Operating System
• Linux Files & Process
• The Directory Structure
• Permissions
• Process

Keeping up the same pace, we will learn the following topics in the 2nd part of the Linux series.

• Shell Scripting
• Networking
• Files & Directories
• Chaining Unix Commands
• Pipes
• Filters
• Word Count Exercise
• Special System commands
• Environment variables

Writing first shell script

A shell script is a file containing a list of commands. Let’s create a simple command that prints two words:

1. Open a text editor to create a file myfirstscript.sh:

nano myfirstscript.sh

2. Write the following into the editor:

#!/bin/bash
name=linux
echo "hello $name world"

Note: In Unix, the extension doesn’t dictate the program to be used while executing a script. It is the first line of the script that would dictate which program to use. In the example above, the program is “/bin/bash” which is a Unix shell.

1. Press Ctrl +x to save and then “y” to exit

2. Now, by default, it would not have executable permission. You can make it executable like this:

chmod +x myfirstscript.sh

3. To run the script, use:

./myfirstscript.sh

Continue reading “A Simple Tutorial on Linux – Part-2”

We have started this series of tutorials for Linux which is divided into two blog posts. Each one of them will cover basic concepts with practical examples. Also, we have provided the quiz on some of the topics that you can attend for free.

In the first part of the series, we will learn the following topics in detail

• Linux Operating System
• Linux Files & Process
• The Directory Structure
• Permissions
• Process

Introduction

Linux is a Unix like operating system. It is open source and free. We might sometimes use the word “Unix” instead of Linux.

A user can interact with Linux either using a ‘graphical interface’ or using the ‘command line interface’.

Learning to use the command line interface has a bigger learning curve than the graphical interface but the former can be used to automate very easily. Also, most of the server side work is generally done using the command line interface.

Linux Operating System

The operating system is made of three parts:

1. The Programs

A user executes programs. AngryBird is a program that gets executed by the kernel, for example. When a program is launched, it creates processes. Program or process will be used interchangeably.

2. The Kernel

The Kernel handles the main work of an operating system:

• Allocates time & memory to programs
• Handles File System
• Responds to various Calls

3. The Shell

A user interacts with the Kernel via the Shell. The console as opened in the previous slide is the shell. A user writes instructions in the shell to execute commands. Shell is also a program that keeps asking you to type the name of other programs to run.

Continue reading “A Simple Tutorial on Linux – Part-1”