DEV Community: yash sugandh

Optional: Handling NullPointer Graciously

yash sugandh — Tue, 21 Dec 2021 13:30:53 +0000

We all know about a billion dollar mistake known as the NullPointer Reference, we all have regular encounters with Null Pointer and sometimes even had to face the wrath of NullPointer Exception. The topic we are going to look into today Optional is going to provide us a way to handle this issue much more graciously.

What is Optional and why was it introduced?

Optional is class introduced in Java 8 under java.util package that allows us to avoid NullPointer Exception that we encounter a lot of times.

Optional provides us a way to check and use whether a value is null or not .This way we can save ourself from the wrath of NullPointers and handle them in a way that is elegant, easy to use and maintain i.e. without using a ton of if-else everywhere to check if an object is null or not.

Where can we find Optional being used?

Now we all know that we should never return null from a method, right?

If you are one of those people who return null from a method and you know who you are don't hide it, please refrain from doing so.

Jokes aside, there are other scenarios where we are not sure if we will receive a value or not, such as when we use Streams findfirst() method i.e. a method that returns the first value of a Stream if the Stream is non-empty so there is possibility a value may not be returned in case the Stream is empty hence an Optional is returned.

Another example that we generally use is the findById() method which is used to get the data from database on the bases of an id so the method may not return a value in case Id is not found in database hence provides us with an optional.

How do we create an Optional?

There are three different ways of creating an Optional

1.Creating an empty Optional

Optional.empty()

The above method creates an empty Optional i.e. an optional with no value inside

2.Creating an Optional some non null value
Optional.of(10)
Optional.of("abcd")
and so on

We can create Optional with different type of values integer, string or an object.

For the cases where values can also be null we have the following

3.Creating an Optional which can also contain null value

Optioanl.ofNullable(10)
Optional.ofNullable(null)
and so on.

The Optional.ofNullable() can be used in the cases where there is a possibility of the value being a null reference.

Now that we know how to create Optionals the next step is to check whether an Optional contains a value or not

1.isPresent()

In Java 8 the best way to check whether an Optional has a value or not is to use the method isPresent().

This method structure is as follows

   public boolean isPresent() {
        return value != null;
    }

The method return us a boolean after checking if a value is present inside an Optional or not.

It returns a true if a value is present otherwise it returns false.

Let's look at example on how to use the method

   final Optional<Integer> optionalInteger = Optional.of(10);
   final Optional<Object> emptyOptional = Optional.empty();

   System.out.println(emptyOptional.isPresent());
   System.out.println(optionalInteger.isPresent());

The output for emptyOptional is be false and the optionalInteger is true.

2.isEmpty()

In Java 11 another method was introduced for checking whether optional contains a value or not.

This method structure is as follows

    public boolean isEmpty() {
        return value == null;
    }

If a value is not present it returns true, otherwise it returns false.

Let's look at example on how to use the isEmpty() method

 final Optional<Integer> optionalInteger = Optional.of(10);
 final Optional<Object> emptyOptional = Optional.empty();
 System.out.println(emptyOptional.isEmpty());
 System.out.println(optionalInteger.isEmpty());

The output for emptyOptional is be true and the optionalInteger is false.

From what we can see from examples both the isPresent() and isEmpty() work in kind of similar manner except that one checks whether the value is present in Optional and other checks for whether the Optional is empty or not.

So based on the requirement we have we can use either or those.

There are cases where we want to perform an operation if the value is present.

In this scenario we can of course use the combination of if(isPresent()) but this will just lead us back to how we use to deal with null references before Optional using if-else statement which we don't want to do.

So for use cases like this we have a method

3.ifPresent()

The ifPresent() method will only execute the operation if the Optional contains some non null value.

This method structure is as follows

    public void ifPresent(Consumer<? super T> action) {
        if (value != null) {
            action.accept(value);
        }
    }

The method does not return anything and what it takes as a parameter is a Consumer.

Let's take an example on how to use ifPresent()

 final Optional<Integer> optionalInteger = Optional.of(10);

 optionalInteger.ifPresent(integer -> System.out.println(integer + 10));

In the example above we can see that the output will only be printed if the value is present and in other cases no output will be printed

What if we want to print something or execute a different function if Optional does not contain any value?

4.ifPresentOrElse()

Introduced in Java 9, the ifPresentOrElse() allows us to provide an alternative in which even if the Optional is empty we can perform an action

This method structure is as follows

    public void ifPresentOrElse(Consumer<? super T> action, Runnable emptyAction) {
        if (value != null) {
            action.accept(value);
        } else {
            emptyAction.run();
        }
    }

So if a value is present, it will perform the given action with the value, otherwise it will perform the given empty-based action.

Let's take an example on how to use ifPresentOrElse()

    final Optional<Object> emptyOptional = Optional.empty();

    emptyOptional.ifPresentOrElse(
        val -> System.out.println("The value present inside the optional is  " + val),
        () -> System.out.println("The optional is empty"));

In the above example we can see that the method will print the value if it is present else it will print "The optional is empty".

Till now we have various methods that help us in checking whether the value is present or not bu what if we want to use the value.

1.get()

NEVER USE THIS METHOD

The get() as the name suggest tries to get the value from the Optional and if the value is not present it will throw a NoSuchElementException.

Using this method after checking if the value is present or not is still considerable but using it without even checking defeats the whole purpose of using the Optional in the first place.

The method structure is as follows

 public T get() {
   if (value == null) {
        throw new NoSuchElementException("No value present");
      }
        return value;
    }

Methods that can be used instead of get() if you just want to access the value inside the Optional are

2.orElse()

One of the way is that we can provide a default value to be used in case no value is found inside the Optional.

The method structure is as follows

    public T orElse(T other) {
        return value != null ? value : other;
    }

As the name suggests the method orElse() will return the value if a value is present inside the Optional if no value is present we can provide a default value i.e. "other" parameter to be returned.

Let's look at an example on how to use orElse()

 final Optional<Object> emptyOptional = Optional.empty();

 System.out.println(emptyOptional.orElse(10));
System.out.println(emptyOptional.orElse(generateRandomNumber()));

In the above example the first output will display 10 as the Optional we used is an emptyOptional so the default value we passed in orElse() will be used and for the second print statement a default value will be provide from the method "generateRandomNumber()".

Another way we can get value without worrying about "NoSuchElementException" is

3.orElseGet()

The method orElseGet() is very similar to the method we saw above orElse(). We can provide both a default value directly as well call a function to provide us with a value.

The method structure is as follows

    public T orElseGet(Supplier<? extends T> supplier) {
        return value != null ? value : supplier.get();
    }

As we can see that the method orElseGet() takes in a Supplier as an input which is used in cases where Optional does not contain any value.

The difference between the structure of orElse() and orElseGet() is clear that orElse method accepts a generic parameter T where as orElseGet method accepts a supplier.

Let's look at an example on how to use orElseGet()

 final Optional<Object> emptyOptional = Optional.empty();

  System.out.println(emptyOptional.orElseGet(() -> 10));
  System.out.println(emptyOptional.orElseGet(() -> generateRandomNumber()));

In the above example the first output will display 10 as the Optional we used is an emptyOptional so the default value we passed in orElseGet() will be used and for the second print statement a default value will be provide from the method "generateRandomNumber()".

The difference between `orElse()` and `orElseGet()`

We were able to see that on the surface both the methods look and works almost the same but structure wise orElse uses the generic parameter where as the orElseGet uses the Supplier.

The major difference between the two method which impacts the performance is when we use orElse even in the cases where the default value is not used it will be created and stored in memory but in case of orElseGet it will only be created if and when needed.

If the default value is a simple int it may not such a big difference but imagine the cases where a method is being called it will not only take a place in call stack but also has the ability to affect the performance.

Another case that may be possible is when we do not want to provide a default value but we want to throw an error in case a value is not present in Optional.

4.orElseThrow()

There are 2 different variants of orElseThow

1.Default variant

Introduced in Java 10 the default variant of orElseThrow works similar to how get() works i.e. if will check whether an element is present or not and if an element is not present it will throw and "NoSuchElementException".

The structure is as follows

  public T orElseThrow() {
     if (value == null) {
        throw new NoSuchElementException("No value present");
      }
     return value;
    }

The difference between theget() and orElseThrow() method is that even though internally both will throw the same "NoSuchElementException" exception when a value is not present, the person going through the code will be able to understand that method orElseThrow can throw an error by just looking at its name where as in the method get it will be a side-effect.

Let's look at an example on how to use orElseThrow()

    final Optional<Object> emptyOptional = Optional.empty();

    emptyOptional.orElseThrow();

In the above example we can see that an "NoSuchElementException" will be thrown.

2.Parameterized variant

Introduced in Java 8, in this variant we can define the error we want to throw if no value is present inside the Optional.

The structure is as follows

    public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
        if (value != null) {
            return value;
        } else {
            throw exceptionSupplier.get();
        }
    }

Let's look at an example on how to use orElseThrow()

   final Optional<Object> emptyOptional = Optional.empty();

    emptyOptional.orElseThrow(IllegalStateException::new);
    emptyOptional.orElseThrow(() -> new IllegalStateException("Data Not Found"));

In the above example we can see that an "IllegalStateException" will be thrown if value is not present in Optional.

We can either create an exception with default constructor or we can also pass in a message.

Now we have gone through

How to create an Optional
How to check if an Optional contains any value or not
How to proceed if an Optional has a value
How to provide a default value

What if we want to transform a value inside an Optional

For the purpose of transformation Optional provides us with various functions such as map, flatmap and filter.

When To Use an Optional

1.Return Value
Optional is suitable to be a return value where expected that a value may or may not be present.

For example the findById method or the findFirst method.

When Not To Use an Optional

1.As a parameter

I have seen some cases where someone has used Optional as a parameter of a method

For example

  public void function1(Optional<Integer> val){
    if (val.isPresent()){
      function2(val);
    }else{
      function3();
    }
  }

In the example above we can see that optional is being misused.

Issues in the above example:

Single Responsibility Principle is being violated
The parent function should have handled the choice instead of the child function
Why would you want to check if a parameter exists or not, instead why not create 2 separate functions for each use case

2.Wrapping a collection such as ArrayList in Optional

I have seen some cases where an ArrayList is being passed wrapped inside an Optional and later is being checked where it is empty or not

I don't know why would someone do it, if you want to check a collection is empty or not than there are already methods created for it so why would you need to wrap a collection in Optional.

Let me know if you have some more use cases of when and when not use an Optional.

See you in the funny papers 🚀

Generics In Java

yash sugandh — Wed, 21 Apr 2021 11:20:13 +0000

What is the meaning of Generics?

One of the definitions from Java docs :

Generics allow you to abstract over types. The most common examples are container types, such as those in the Collections hierarchy.

In English:

Abstract over type means to group together similar and generalize them.

For Example: what do we do if we need to save firstName, lastName and email of multiple people do we create n number of variables to store and retrieve them manually OR
we create an Abstraction over it known as Class.

Great!, Now we know what abstract over type means, but I still don't get how is it beneficial to us???

In short: Generics provides us with compile time type-checking and saves the need of manual type-casting.

In depth: Let's find out

Let's take an example of how Collection's used to work before introduction of generics.

List numList = new ArrayList(); // 1
numList.add(new Integer(1)); // 2
Integer x = (Integer) numList.iterator().next(); // 3

Line 1 and Line 2 are simple, we created an ArrayList and added an Integer.

On Line 3 we have something that looks painful and will probably make you a little irritated Manual Type Conversion

Just imagine doing that every single time.

In the above case even though the developer knows that the data is Integer at compile time we still need to manually convert it to Integer.

This was the best case scenario where even though it looks bad it still works what if

List list = new ArrayList(); //1
list.add("abc"); //2
list.add(new Integer(5)); //3 

for(Object obj : list){
    Integer numbers=(Integer) obj; 
}

Line 1 we created an ArrayList
Line 2 we add a String to list
Line 3 we add an Integer to the list

Wait what!!
We first added a String and now an Integer to the same list

Okay what's next
we iterate over List and try to manually type cast it to Integer

So, we added a String and an Integer, and now we are expecting both of them to be type-casted to an Integer

You know what's coming

ClassCastException 🎆 💥

We all know someone who is capable of doing this 😉

What were the problems we found till now:

We need an abstraction over these so that we don't need to manually convert it every time
We need a compile time check to save us from ClassCastException

This is what our savior Generics helps us with

How? Let's find out

List<String> listOfString = new ArrayList<>(); //1
listOfString.add("Generics"); //2
listOfString.add("are"); //3
listOfString.add("Awesome"); //4

for(String str : listOfString){ //5
     //no type casting needed, avoids ClassCastException
}

Most of the lines in the above code looks just as before except the manual typecast is gone 😌 .

There is also something new on line 1
List<String> listOfString = new ArrayList<>();

<> is used in generics to help us define the type of data we are going to store in the list.

That's it that all we need to do for adding a compile time type safety.

What if someone tries to add an Integer to the above list?

If we try to add an Integer we get a compile time error.

So, can we use Generics only with Collections?

No, Collections is just one of the places where we can use Generics. Let's look at other places where we can use Generics.

Let's start small

Generic Interface

interface Print<T>{
  void display(T input);
}

We can create generic interfaces which can be implemented by Classes with their respective data-type

class PrintInteger implements Print<Integer>{

  @Override
  public void display(Integer input) {
    System.out.println("Printing an int "+input);
  }
}

We have implemented Print interface and specified the data-type as Integer.

Generics Class and Generic methods

Let's take a situation where we want to store firstName, lastName and an id of an employee but the data-type of id can be an int or long or String.

Code without Generics

class EmployeeWithIntegerId {
private String firstName;
private String lastName;
private int id;
}

class EmployeeWithLongId {
private String firstName;
private String lastName;
private long id;
}

class EmployeeWithStringId {
private String firstName;
private String lastName;
private String id;
}

We can see that without using generics we have to create 3 different classes to cater the situation.

Now, let's use generics to get us out of this situation

Code with Generics

class Employee<T>{
  private String firstName;
  private String lastName;
  private T id;
}

T in the above code represents the data-type of our id which will be decided by us while creating the instance of the class.

Is T mandatory to use?

No, T is just the most commonly used one, but it is not mandatory. We can use any alphabet we like in place of T.

For people who are interested in the best practices in naming convention

The most commonly used type parameter names are:

E - Element (used extensively by the Java Collections Framework)
K - Key
N - Number
T - Type
V - Value
S,U,V etc. - 2nd, 3rd, 4th types

courtesy of java docs

Now, when we use generics we only needed to create a single class where the only thing that needs to be decided was the type of our variable id.

Okay, but how will the getters, setters and constructor work ??

Constructor

  public Employee(String firstName, String lastName, T id) {
    this.firstName = firstName;
    this.lastName = lastName;
    this.id = id;
  }

The constructor will look the same as before. It is one of the best and easy to understand example of generic methods.

Getters and Setters

  public T getId() {
    return id;
  }

  public void setId(T id) {
    this.id = id;
  }

Okay, so we have defined the class, so how can we use it??

Employee<String> employee= new Employee<>("yash","sugandh","1234");

In the above example we created an object of the class Employee and while creating it we used <> operator to define the data-type of T as String.

There is a restriction on data-type that we cannot use primitive data-types, so we cannot use int we have to Integer, Long instead of long and so on.

Now, we know about generics and how it helps us in Collections, Interface, Classes and methods.

But, there are still few questions left

What are wildcards in generics ?
What is the meaning of bounded and unbounded wildcard ?
How does Java ensure backward compatibility from code with generics to code without generics?

Let's cover all these topics in the next post.

Please let me know if there are any questions in the comments below.

See you in the funny papers 🚀

Package Management in Linux System

yash sugandh — Mon, 07 Sep 2020 09:53:49 +0000

In the last few posts, we explored Permissions in Linux System and Changing Permissions in Linux System.

Today, let's take a step in a different direction and understand Package management in Linux System.

Package management is a method of installing and maintaining(update, remove, manage dependency, etc) software in the system.

Softwares are usually distributed in packages and stored in repositories.

Earlier, one had to download and compile source code to install the software.

Now, most of the modern Unix-like operating systems offer a centralized mechanism for finding and installing software.

But before we jump into how the package management system works, let's look into what are the advantages of using it

Ease of installation and removal of software
To keep track of updates and upgrades
To provide consistent usage throughout the devices.
To manage dependencies while installing a new software

Okay, there are different Linux distributions. Do all of them use the same packaging management system?

No, different distributions use different packaging management systems.

So, a package intended for one distribution is generally not compatible with another distribution.

How a Package System Works

Most package management systems are built around collections of package files.

A package file is a collection of files that comprise the software package.

A package may consist of numerous package files and pre- and post-installation scripts that perform configuration tasks before and after the package installation.

Package management systems usually consist of two types of tools.

Low-level tools which handle tasks such as installing and removing package files
High-level tools that perform metadata searching and dependency resolution

The functionality may be similar in all the distributions but their tools are different

Distribution	Format	Low Level Tool	High Level Tool
Debian	.deb	dpkg	apt,apt-cache,apt-get,aptitude
Ubuntu	.deb	dpkg	apt,apt-cache,apt-get
CentOS	.rpm	rpm	yum
Fedora	.rpm	rpm	dnf

dpkg

dpkg is a low-level tool to install, build, remove and manage Debian packages.

apt

apt provides a high-level command-line interface for the package management system.

It is intended as an end-user interface and enables some options better suited for interactive usage.

aptitude

aptitude is a text-based interface package management system.

It allows the user to view the list of packages and to perform package management tasks such as installing, upgrading, and removing packages.

rpm

RPM is a package management system used to build, install, verify, update, and uninstall software.

yum

yum is the high level tool for getting, installing, deleting, querying, and managing Red Hat Enterprise Linux RPM software packages.

dnf

DNF or Dandified YUM is the next-generation version of the Yellowdog Updater, Modified. It is used for getting, installing, deleting, querying, and managing Red Hat Enterprise Linux RPM software packages.

Let's have a look at how do we use these tools:

Debian and Ubuntu

dkg

Task	Command
Install a .deb file	dpkg -i package-file-name.deb
Remove a .deb file	dpkg -r package-file-name.deb
List installed Packages	dpkg --list search-pattern
Check if a package is installed	dpkg -s package-name
location of installed file	dpkg -L package-name

apt

Task	Command
Installs the package(s) with dependency	apt-get install package-name(s)
Remove the package(s) but not dependency	apt-get remove package-name(s)
Remove unused dependency	apt-get autoremove
Update Package List	apt-get update
search Packages	apt search search_string
get info about a package	apt show package

CentOS and Fedora

rpm

Task	Command
Install a .rpm file	rpm -i package-file-name.rpm
Remove a .npm file	rpm --erase package-name(s)
Listing Installed Files	rpm -qa
Check if a given package is installed	rpm --query package-name(s)

yum

Task	Command
Installs the package(s) with dependency	yum install package-name(s)
Remove the package(s) but not dependency	yum erase package-name(s)
Update Package List	yum update
search Packages	yum search search-pattern
get info about a package	yum info package-name(s)

dnf

Task	Command
Installs the package(s) with dependency	dnf install package-name(s)
Remove the package(s) but not dependency	dnf remove package-name(s)
Update Package List	dnf upgrade
search Packages	dnf search search-pattern
get info about a package	dnf info package-name(s)

These are the most common functionalities that these Package Managers Provide.

Hope this will help you better understand the Package management in Linux.

See you in funny papers 🚀

Changing Permissions in Linux System

yash sugandh — Sun, 30 Aug 2020 12:30:21 +0000

In the last post, we explored Permissions in Linux System.

If you have not read the previous post I would strongly recommend you read the last post first.

Now, let's move onto Changing Permissions in Linux System.

1. chmod Command

chmod stands for change file mode is used to change permissions of a file/directory.

Can anyone change the permissions of a file/directory?

No, only the owner or the root user(superuser) can change the file/directory permissions.

There are two way's in which we can change the mode(Permissions)

Absolute mode
Symbolic mode

Absolute mode:

In Absolute mode, we use the Octal Number to represents Permissions for Owner, Group, and Others.

Okay, but what do you mean by Octal Number?

Octal is a number system that is used to represent numbers on a computer.

In Octal, counting is done with numbers from 0 to 7

Octal Number	Type of Permission	Symbol
0	No Permission	---
1	Execute Only	--x
2	Write Only	-w-
3	Write and Execute	-wx
4	Read Only	r--
5	Read and Execute	r-x
6	Read and Write	rw-
7	Read, Write and Execute	rwx

Let's look at the syntax for chmod

To change the mode of a file/directory we just use chmod along with one of the modes from the above table and files/directories.

In the above example, we used the command ls -l hello.txt to check the current permissions for owner, group, and others and found that the owner had read and write (rw-) permission, group also had read and write (rw-) permission and other had read-only permission (r--)

What if to make it more secure we wanted to change the permission for the group to read-only and keep the rest as is

we used the command chmod 644 hello.txt where

chmod represents the command change mode
644 represents read-write, read-only and read-only permissions
hello.txt represents name of the file we want to change permissions for.

Now that we know how to use chmod command let's look at what are some most used modes

Mode	File Attributes	Meaning of mode
777	rwxrwxrwx	No restrictions on permissions. Generally, not a good setting as anyone can change and execute your file
700	rwx------	The owner has full access. Nobody else has any rights. This setting is useful if we want to keep our files and directories private. Similarly we can use 600 for non-executable file
644	rw-r--r--	The owner may read and write a file, while all others may only read the file. This setting is useful if the owner should be the only one to change the file
666	rw-rw-rw-	All users may read and write the file. This setting is useful if you have some common file

Now, let's move on the 2nd way we can change mode

Symbolic Notation

The Symbolic notation is divided into three parts

Who the change will affect

Unlike Absolute mode in Symbolic notation, we can actually specify who should be affected by the change

u represents user(Owner)
g represents group
o represents others
a represents all(i.e. u,g and o)

Which operation will be performed

+ represents an operation to add a permission
- represents an operation to remove a permission
= represents an operation to set permission and replace the previous one

What permission will be set

r represents read permission
w represents write permission
x represents execute permission

Let's take an example of each operation

Add Permission

In the above example, we used the command chmod u+x hello.txt to add executable permission to the Owner where

chmod represents the command to change mode
u represents user(Owner)
+ represents the addition of permission
x represents executable permission

Remove Permission

In the above example, we used the command chmod o-r hello.txt to remove the read-only permission from Other where

chmod represents the command to change mode
o represents other
- represents the removal of permission
r represents read permission

Assignment of Permission

In the above example, we used the command chmod g=wr hello.txt to assign the read and write permission to group where

chmod represents the command to change mode
g represents group
= represents the assignment of permission
wr represents read and write permission

Note: If we don't specify who will be affected, it is by default taken as all

This was all about changing permissions of a file/directory.

Now, let's look at how to change ownership and group of a file/directory.

chown Command

The chown command is used to change the owner/group of a file.

Let's take an example

In the example, we can see that the owner and group of the file hello.txt is "yash".

Let's try and change the owner of the file to "root".

Since we are changing the ownership of the file this operation will require the root access

In the above example, we first tried changing the ownership without using root privileges and it gave us an error.

Then we used the command sudo chown root hello.txt command where

sudo for executing as a superuser
chown represents the change ownership command
root represents the new owner
hello.txt represents the file to be affected

Let's take another example where we change our owner back to "yash" but change our group to "root"

In the above example, we used the command sudo chown yash:root hello.txt where

sudo for executing as a superuser
chown represents the change ownership command
yash represents the new owner
root represents the new group
hello.txt represents the file to be affected

What if we just wanted to change our group?

chgrp Command

To change the group using chgrp command we just use chgrp newGroupName fileName

Let's take an example, we recently changed the group of our file "hello.txt" from "yash" to "root".

Now, let's change it back

In the above example, we used the command chgrp yash hello.txt where

chgrp represents the change group command
yash represents the new group
hello.txt represents the file to be affected

So, this was all about Changing Permissions in Linux System. Hope you understood.

Please let me know if there are any queries and suggestions.

See you in the funny papers 🚀

Permissions in Linux System

yash sugandh — Sat, 22 Aug 2020 11:07:39 +0000

In the last post, we explored Controlling Processes in Linux System where we explored how to control processes running in our System.

Today we are going to explore one of the most important topics in the Linux System: Permissions.

What are permissions and why should we know about them?

Our Linux Systems are built on top of the Unix system, so they are not just multitasking but also a multi-user system.

This is not something that has been recently introduced but has been deeply embedded in the Linux systems from the early days.

What does a multi-user system mean?

In a multi-user system, more than one person can be using the computer at the same time.

For example, if you are connected to the internet, the remote users can access your system using Secure Shell(ssh).

Okay, this feature provide users with great power to login from anywhere.

To quote a great man:

With Great POWER comes Great Responsibility

Sorry just could not miss the opportunity to say this 😁

Okay let's get back to the topic since multiple users can log in into the same system along with a malicious user, how can you make sure that your files are secure?

This is where Permissions comes into the picture.

Permissions are divided into two major parts:

Ownership
Access Rights

1. Ownership
Files and directories in the Linux system is assigned 3 types of owner

Owner (the user who created the file/directory)
Group (to which the owner belongs to)
Others (all other users)

2. Access Rights
Files and directories in the Linux system have 3 access rights defined for all the 3 owners discussed above.

Read access denoted by r
Write access denoted by w
Execution access denoted by x

Okay so we have just found the answer what are Permissions and why should we know about them.

Now, the next question that comes into our mind is how can we check Permissions for a file or directory?

There are two easy ways we can check for Permissions on a file/directory

1. Using the UI

Let's start with the human-readable way

To check Permissions for a file/directory all we need to do is

Right-click on a file
Select properties from the menu
There we have 4 tabs Basic, Permissions Open with and Image(Type of file)

Select the Permissions tab

After selecting Permissions we see the following data

In the above image,

Owner has a value of me since I was the one who created the file
Access provided for Owner is read and write
Group has a value of yash since that is my username
Access for the group is also read and write
Others have read-only access.

To change Permissions, the user can open the drop-down menu for each category and choose the desired permission.

Aren't we missing something? Where is the execution access?

If we look below the Access of others we can see that there is another field name Execute.

Execute allows us to check whether this file is executable or not and since in the above image checkbox is not ticked we can say that the file is not executable.

2. Using our Terminal

To find Permissions for files all we need to do is use ls command along with -l option.

In the above example, we used the command ls -l to list all the files and directories along with Permissions.

But to understand how to read Permissions better let's take an example of a single file

In the above example, we used the command ls -l I_O\ Redirection\ In\ Linux\ System.png to find the permissions for the respective files

In the Output -rw-rw-r-- 1 yash yash 75880 the first 10 letters are file attributes

The first letter describes the type of file, most common file types are

- specifies a regular file
d specifies a directory
l describes a symbolic link

After the type of file, we have the rest of 9 characters to describe access permissions i.e. rwx( read, write and execute).

In the above example, we have

rw - Read and Write for Owner
rw - Read and Write for Group
r - Read Only for all the Others

Similarly, we can have many different combinations of Permissions. Let's look at a few

File Attributes	The Meaning of Attributes
-rw-rw-r--	A regular file that is readable and writable for Owner and Group but only readable for others
drw-r-r--	A directory that is readable and writable only for Owner and for Group and Others it's only readable
-rwx------	A regular file that is readable, writable, and executable by the Owner. No one else has any access.
-rwxr-xr-x	A regular file that is readable, writable, and executable by the Owner. The file can only be read and executed by everybody else.

So, this is how we can read Permissions for a file/directory.

This is it for this post. In the next post, we will explore how to add/edit these permissions from Terminal.

See you in the funny papers 🚀

Controlling Processes in Linux System

yash sugandh — Sun, 16 Aug 2020 05:41:03 +0000

In the last post, we explored Processes. what are processes and how can we monitor them?

In this post, we will explore how can we control these processes?

We learned in the last post that there are two types of processes :

Foreground Processes
The foreground processes are those which can be seen on UI and require some sort of user input.
For example, a text editor.
Background Processes
The background processes are those which do not require any form of input from the user and run automatically in the background.

Let's take an example, that we want to run a Spring Boot Gradle application using the command gradle bootrun.

Now the process has started but we cannot access the terminal.

What if we want to move the process in the background?

To move the process in the background all we have to do is press Ctrl + Z

In the above example, we can see that the process is now moved to the background and it returns the process id (PID) along with status of suspended.

But what is the meaning of suspended here?

The suspend state specifies that our process is not terminated but is present in a suspended state.

Okay, so when we use the Ctrl + Z the process is temporarily stopped.

What if we wanted to bring the process to the foreground again?

To bring the process to foreground we use the command fg

In the above example, we moved our process to the foreground again using the command fg and it returned us the status continued with PID.

Now, what if we want to terminate the process?

To terminate a process we press Ctrl + C

In the above example, we pressed Ctrl + C to terminate the running process.

Till now we have seen how to run a process in the foreground, move the process to background, and bring the process to the foreground again.

What if we wanted to start the process in the background?

To run a process in the background all we need to do is write & at the end of our command

Let's take an example that we want to run gedit in the background

In the above example, we used the command gedit & and ran the process in the background and we got a process id(PID) in return.

So the process is running in the background but how can we confirm it?

To check all the processes in our current terminal we use the command jobs.

In the above example, we can see that a job is running in the background named gedit.

Now, we have already seen how to bring a process to the foreground but what if there are multiple processes?

To bring a specific process to the foreground we use the following syntax

fg #{process_number}

Let's take an example and bring our gedit job to the foreground

In the above example, we used the command fg #1 and brought the gedit process to the foreground again.

Now, let's have a look at how to control processes using signals

We use the kill command to send signals to programs.

There are many different signals we can send using the kill command and we can list these signals using the command kill -l.

Let us explore a few of the most used signals

Signal	Value	Description
SIGHUP	1	Hangup detected on controlling terminal or death of controlling the process
SIGINT	2	Interrupt from keyboard It is the action performed when we press Ctrl + C
SIGQUIT	3	Quit from keyboard
SIGKILL	9	Immidiately kill the process without any time for cleanup
SIGTERM	15	It is used to Terminate a process. It is the default action with KILL command
SIGCONT	19,18,25	Used to Continue the process if stopped
SIGSTOP	17,19,23	Used to Stop a process

The signals SIGKILL and SIGSTOP cannot be caught, blocked, or ignored.

To kill any process using kill command we need the PID of the respective process.
We can either use the name of the signal or the value of a signal along with PID to kill any process.

Let's take an example, that we want to kill the screenshot application

In the above example, we first searched for the PID using the command we learned in the last post ps -ef | grep screenshot.

We used the kill command along with signal value as well as with signal name to kill the screenshot application.

What if we wanted to kill the process with name and not PID?

To kill a process with a name we use the pkill {regular_expression}

Let's take an example, we used the command pkill fire. This command, when executed will kill every process starting with fire.

What if we want to kill all the instances of a running application? Is there any way we can do it in 1 go?

We can kill multiple instances of an application using the killall command.

The main difference between killall command and pkill command is that we need to provide exact value to killall command.

In the above example, we used the commands pkill and killall to kill gedit. While executing we observed that when we give killall command an incomplete name the killall was unable to find the processes.

This was all about how we can control the processes.

Please let me know if you have any suggestions or queries in the discussion below. See you in the funny papers.

All about processes and how can we view them

yash sugandh — Sat, 08 Aug 2020 12:22:03 +0000

Linux is a multitasking operating system, which means that it creates an illusion that multiple programs are running at the same time by rapidly switching from one program to another.

The Linux kernel manages this through the use of processes.

Each process has the illusion that it is the only process on the computer. The tasks share common processing resources (like CPU and memory).

What exactly is a process?

An instance of a program is called a Process. A process can be simply called as a program in execution.

Every time we run a shell command, a program is run and a process is created for it.

Each process in Linux is assigned an ID called process id (PID).

There are two types of processes :

Foreground Processes
The foreground processes are those which can be seen on UI and require some sort of user input.
For example, a text editor.
Background Processes
The background processes are those which do not require any form of input from the user and run automatically in the background.

For example, an antivirus.

There are different state of a process:

Running - The state where a process is either in running or ready to run(waiting for CPU time).
Interruptible - A blocked state of a process that waits for an event or a signal from another process.
Uninterruptible - The process is forced to halt for certain conditions that a hardware status waits and a signal could not be handled.
It is also known as a blocked state.
Stopped - Once the process is completed, this state occurs. This process can be restarted.
Zombie - In this state, the process will be terminated and the information will still be available in the process table. We get a Zombie process when a parent process dies before child.

The first process that starts when a Linux system boots up is the init process.

The kernel looks for init in /etc. If the kernel can't find init, it tries to run /bin/sh, and if that also fails, the startup of the system fails.

The PID we find out about above is assigned to a process when it is created and since the init is the first process after the Linux system boots up the PID of init is 1.

Till now we have seen what process is and how it works. Now let's look at how to view the processes that are running in our system.

1. pidof command

The pidof command is used to find the process id's of a running application.

To get the PID of a process we just use pidof along with the application name.

In the above example, we used the command pidof init which we know should return 1 and it did.

We also tried pidof java which returned multiple processes running for java.

2. ps command

The ps command returns the snapshot of the current processes.

In the above example, the ps command by default shows us all the processes that are associated with the current terminal.

TTY is short for “teletype,” and refers to the controlling terminal for the process.

Unix is showing its age here. The TIME field is the amount of CPU time consumed by the process.

To get the list of all the processes running we use the ps command along with two options e which specifies all processes and f which specifies full description.

In the above example, we used the command ps -ef to get the details of all the processes running.

What if we wanted to find a process id of a specific process?

find the PID of firefox application

In the above example, we used the command ps -ef | grep firefox to get processes running for firefox so that we can get the PID of firefox.

But, what if I tell that there is a way through which we won't need to write such long command?

3. pgrep command

The pgrep command is used to get the process id of an application.

It is similar to the pidof command is much more powerful as we do not need to provide the exact name of the application.

In the above example, we tried to find an application that has "idea" in its path.
When we tried it with pidof we got no response but when we tried the same with pgrep we got the PID.

4. top command

This utility tells the user about all the running processes on the Linux machine(It refreshes the data every 3 seconds by default).

The name top comes from the fact that the top program is used to see the “top” processes on the system.

In the above example, we can see the following

Field	Description
PID	The process ID of each task
User	The username of task owner
PR	Priority Can be 20(highest) or -20(lowest)
NI	The nice value of a task
VIRT	Virtual memory used (kb)
RES	Physical memory used (kb)
SHR	Shared memory used (kb)
%CPU	% of CPU time
%MEM	Physical memory used
TIME+	Total CPU time
Command	Command Name

These were the tools we can use to view the processes. Please let me know if I missed something.

In the next post, we will discuss various ways to control processes. See you in the funny papers.

History Command and How to Use It?

yash sugandh — Sun, 02 Aug 2020 06:48:17 +0000

In this series, we have looked at so many commands with their different syntaxes and options, and it's very very hard to remember each and every one of them.

So, today we are going to have a look at a command which allows us to have a look at all the commands that we have used previously and use them again.

By the title, you would have already guessed what the command is, right?

It's history command!!

The first question we have is, what is the use of history command?

The history command is used to view all the previously executed commands.

Why do we need history command?

The main use of history is to find an already executed command and use it again.

It can also be used for audit purposes or to find out what command was executed at a specific date and time.

Now, without wasting any more time let's get started

To get all the commands we have previously executed

To use the history command we simply type history and press ENTER

As soon as we press ENTER we get the list of all the commands.

By default, the bash used to store around 500 commands in the history but nowaday's the limit has gone up to 1000 commands.

To make the scrolling of commands a little easier we can use the history command along with the less command i.e. history | less.

But, what if we wanted to find only the last 10 commands

List the last 10 commands that we executed

In the above example, we used the command history along with the number of commands we wanted to have a look at.

Note: The above syntax i.e. history {number} will not work with zsh because in zsh, history is an alias for fc -l 1, so when you do history 10 it gets replaced by fc -l 1 -10 which just won't work, so instead use fc directly: fc -l -10.

Now, what if we want to list them along with the time

In the above example, we first used the command
$ HISTTIMEFORMAT="%d/%m/%y %T " which is used to set the time format day/month/year timestamp
After the format is set we used the command history to get the desired results.

Note: For zsh we just need to use history -i to get the same results.

What if we wanted to find the history of all the times we used a specific command?

In the above example, we used the command history| grep man to get all the times we have used the man command

Till now we have seen different way's to get the commands.

But what if we wanted to use these commands.

For starters, what if after looking through history we found out the command we want to use has the x serial number. How will we use it?

So let's see how we can use the commands from our history

use a command on the serial number 1343

In the above example, we used !1343 to execute the command at the respective serial number.

But this can land us into a lot of trouble if we typed the wrong serial number.

Is there anything we can do to prevent this?

Let's take an example to see how to prevent this

In the above example, we first used the command !1343:p which returns the command at the number and after verification, we can execute the command.

There is another feature that history provides known as History Expansion

History expansion is a way to recall and edit commands in the history list. The way to recall commands is by the use of event designators.

Command	Description
!!	It refers to the last command
!-n	It will execute the current number -n command
!string	It will execute the command referring to the most recent command starting with input string
!?string	It will execute the most recent command that ends with the input string
^string1^string2	Repeat the last command, replacing string1 with string2

We can also use !! to execute the last command but we would rarely use it since we can easily use the up key instead.

Let's take a few example's to understand better

find the last cat command that was executed and run it

find the last command performed on "Hello.txt" and perform it again

Similarly, we can use other history expansions as well.

So, this was all about the history keyword and how we can use it.

Hope you understood it and please let me know if there are questions and suggestions down below.

See you in the sunny papers :)

Keyboard Shortcuts For Linux Terminal

yash sugandh — Sat, 25 Jul 2020 11:55:32 +0000

In the last post, we looked at the use of an Alternative of find command fd command.

Today, we are going to have a look at the keyboard shortcuts for Linux Terminal that will make our life easier.

Let's have a look at some basic and most useful commands

Keyboard Shortcut	Use of the keyboard shortcut
Ctrl-Alt-t	Open a new Terminal
Ctrl-d	Close a terminal
Ctrl-c	Cancels the currently running command.
Ctrl-l	Clears the screen just like clear command

In the above command, the one that I use the most is the Ctrl-l since it allows me to clear the screen without the need of typing the clear command again and again.

Now, Let's have a look at some advanced commands to help our movement in terminal

Keyboard Shortcut	Use of the keyboard shortcut
Ctrl-a	Move the cursor to the beginning of the line
Ctrl-e	Move the cursor to the end of the line
Ctrl-f	Move the cursor forward by one character
Ctrl-b	Move the cursor backward by one character
Alt-f	Move the cursor forward by one word
Alt-b	Move the cursor backward by one word

We can use home and end key to move at the beginning and end of the line as well.

The ability to move at the beginning or end of a word using Alt-f Alt-b is what I find most useful since we don't have to move back character by character.

Now let's have a look at some shortcuts that can help us in modifying text

Keyboard Shortcut	Use of the keyboard shortcut
Ctrl-d	Delete the character at the cursor location
Ctrl-t	Exchange the character at the current location with the character at preceding it
Ctrl-u	Erases the complete line
Alt-t	Exchange the word at the current location with the word at preceding it
Alt-l	Move the cursor backward by one character
Alt-u	Convert the characters of a word to lowercase from the current cursor location
Alt-b	Convert the characters of a word to uppercase from the current cursor location

Alt-t is something that you don't think you need until you start using it.

So this is all for today. Let me know what's your most used and if I missed something just let me know in the discussion below.

You can also join me on my journey of Linux-for-beginners series

Piping in Linux System

yash sugandh ・ Jun 27 '20

#linux #ubuntu #beginners #computerscience

Filter Commands in Linux System

yash sugandh — Sun, 19 Jul 2020 05:50:25 +0000

In the last post, we looked at viewing and sorting of files.

There are many times that we want to look at only a specific part of the file and even more times when just want to analyze the file content.

In this post, we are going to have a look at basic commands to filter the contents of a file.

1. grep command

The grep command is used to search text or search the given file for lines containing a match to the given strings or words.

The syntax for grep command

To filter a file using grep we use grep along with the options like "case", patterns we want it to match and the source files.

Let's take an example

We have the following log file

filter out which user is mentioned in the logs

In the above example, we used the command cat logs.txt | grep user@ where

cat represents cat command to read the file content
logs.txt represents the file to read content from
grep represents the grep command
User@ represents the text we used to filter the logs.txt file.

Note: The grep command by default is case-sensitive

get the same output as above using User@ as the pattern

In the above example, we first used the command to check whether we can directly use the User@ but it did not work sincegrep is case-sensitive so to fix this we used the command

cat logs.txt | grep -i User@ where
cat represents cat command to read the file content
logs.txt represents the file to read content from
grep represents the grep command
-i represents the option to filter case-insensitive
user@ represents the text we used to filter the logs.txt file.

We can also use the grep command to get the count of a specific word

find number of occurrences of the word "exceed"

In the above example, we used the command cat logs.txt | grep -ic exceed where
cat represents cat command to read the file content
logs.txt represents the file to read content from
grep represents the grep command
-ic represents the option to count the number of **occurrences of the word irrespective of the case
exceed represents the text we used to filter the logs.txt file.

What if we need to revert the above case?

find the count of words that do not match the word "exceed"

In the above example, we used the command cat logs.txt | grep -cv exceed where
cat represents cat command to read the file content
logs.txt represents the file to read content from
grep represents the grep command
-cv represents the option to count the number of occurrences of the words not matching
exceed represents the text we used to filter the logs.txt file.

Let's move on to the next command

2.wc command

The wc stands for word count is used for printing the number of lines, words, and bytes contained in files

The syntax for wc command

To use the wc command we simply use wc along with options and files

Let's take an example

In the above example, we used the command wc logs.txt to get the number of lines, words, and bytes.

get only the number of lines in a file

In the above example, we used the option -l and created a command wc -l logs.txt to get the number of lines.

Similarly, we can use -w for words, -c for bytes and -m for characters

3.uniq command

The uniq command is used to report or omit repeated lines.

By default, uniq prints its input lines, except that it filters all but the first of adjacent repeated lines so that no output lines are repeated.

uniq is mostly used with sort command. the sort command provides with the sorted input and uniq command removes the repeated lines.

Let's take an example of the following file

use unique to filter file contents

In the above example, we first used the command sort random-words.txt | we to find the current count and then to get the unique values only we used sort random-words.txt | uniq | wc where

sort represents sort command
random-words.txt represents the input file
uniq represents uniq command
wc represents wordcount command

4.tr command

The tr command is used to translate, squeeze, and/or delete characters.

The syntax for tr command

By default, the tr command will replace each character in SET1 with each character in the same position in SET2.

Let's take examples for better understanding

convert lowercase to uppercase

In the above example, we used the command tr "[:lower:]" "[:upper:]" where
tr represents tr command
[:lower:] represents SET1 all the lower-case letters[abcd...]
[:upper:] represents SET2 all the upper-case letters[ABCD...]

delete a specified character

In the above example, we used the command cat hello.txt | tr -d 'o' where
cat represents the concatenation command
hello.txt represents the input file
tr represents tr command
-d represents the delete option
o represents character to be deleted

join all the lines into a single line

In the above example, we used the command tr -s '\n' ' ' < logs.txt where
tr represents tr command
-s represents squeeze repeats
\n represents a new line
' ' represents single space
logs.txt represents the input file

5.head and tail command

In the recent past, we already had a look at this command. Let's take a recap.

head command is used to print the lines from the start of the file whereas the tail command is used to print the files from the bottom of the file.

Let's take an example for better understanding

print only the first two line from a file

In the above example, we used the command head -n 2 groceryFinal.txt where

head represents the head command
-n 2 represents the number of lines option
groceryFinal.txt represents the file we want to read

print only the last two lines from a file

tail represents the tail command
-n 2 represents the number of lines option
groceryFinal.txt represents the file we want to read

So head and the tail command is basically used to view the snippet of file content.

Note: There are two commands sed and awk that I have purposefully left out to cover them later in deep.

So these were the commands to filter file contents. If I missed any please let me know in the discussions below.

Also, let me know if you have any questions down below. See you in the funny papers.

fd - Best alternative to Find Command

yash sugandh — Sat, 11 Jul 2020 14:26:35 +0000

Last few posts in Linux For Beginners has been quite hectic. So I thought why not learn something fun and useful today the fd command.

I know what you are thinking that learning a command is not a very nice way to have fun but if you are like me then learning something new that easy to use but packs quite a punch will definitely bring a smile to your face.

So let's not waste any time and go-ahead to our today's topic fd command.

The fd command is a simple, fast, and user-friendly alternative to find.

So why use this over find?

We use fd over find because

It's easy to use
Does not look in hidden files and directories by default.
It's faster than the find command
Parallel command execution
Ignores patterns from your .gitignore, by default.

I can keep going but let's look at them in detail later :)

So, can we replace find with fd?

Well not exactly, fd covers almost 80% of find utilities. So think of fd as an extension to the find command.

Let's start with how to install the fd command

To install fd on Debian we use

sudo apt install fd-find

For some other Distros

Fedora:

dnf install fd-find
Alpine:

apk add fd
Arch Linux:

pacman -S fd
Mac OS:

brew install fd

If I missed your Distro look into fd command docs

Note: In some distros like Debian there is already a package installed named fd so we install fdfind. To use fd we can just set

alias fd=fdfind

in our shells initialization file.

Now that we have installed fd let's start using it

The syntax of fd command

To find something we just use fd along with PATTERN(filename, textfiles, images)

In the above example, we used the command fd hello-world which returned us the path to the files named hello-world.

Let's take some more examples for better understanding

Note: In the examples mentioned below we are only seeing a portion of the actual output since the complete output is huge.

find all the JSON files

In the above example, we used the command fd -e json where
fd represents the fd command
-e represents the options to filter using the extension
json represents the filter type JSON files

Now what if we wanted all the JSON files but exclude some unwanted files

exclude idea JSON files

In the above example, we used the command fd -e json -E idea* where
fd represents the fd command
-e represents the options to filter using the extension
json represents the filter type JSON files
-E represents the options to exclude files
idea* represents the files to be excluded idea*

So that was awesome filtering out some unwanted files from search results

Till now we have been searching through all our directories but what if we wanted to search files only in a specific directory

find all .txt files in the Documents directory

In the above example, we used the command fd .txt Documents where
fd represents the fd command
.txt represents the filter type text files
Documents represents the directories we want to find the file in

Another functionality that we need would be to filter the files on the basis of type

-filter on the basis of type directory

In the above example, we used the command fd -td where
fd represents the fd command
-td represents the option to filter the results on the basis of type which in d directory in this case

We can filter on the basis of other types as well

What about the hidden files and directories aren`t they ignored by default then how do we search for those?

search .hidden.txt file

In the above example, we used the command fd -H .hidden where
fd represents the fd command
-H represents the option to search through hidden files and directories.
.hidden.txt represents the file to be searched for

That's it for today let me know if you enjoyed it as much as I did.

Please let me know in the discussion below if you have any questions and you can suggest me in the discussion if you have used some utility that you want others to know and learn about.

Commands for Viewing and Sorting Files

yash sugandh — Mon, 06 Jul 2020 07:57:40 +0000

In the last few posts, we looked at I/O Redirection and Piping in Linux System.

Today we are going to look at commands that help us in viewing and sorting files.

Let's start from the command that we have used before multiple times - cat command.

The cat command is used to concat multiple files together or just read the files.

1.cat command

The syntax for cat command

Let's take an example where we have two grocery lists grocery1.txt and grocery2.txt

First, let's view the file content using cat

Similarly, we can view the 2nd file

In the above examples, we used the command cat <filename> to view the file contents.

What if we wanted to concat these 2 files?

concat above files

In the above example, we used the command cat grocery1.txt grocery2.txt > groceryFinal.txt where

cat represents the concat command
grocery1.txt grocery2.txt represents files to concat.
> represents redirection of Output Stream
groceryFinal.txt represents the output file.

Then to confirm that all the content is present we used cat groceryFinal.txt to view the content of the output file.

But the above output is a little hard to read, what if we wanted to view the output file but numbered?

Let's check it out:-

View the output file numbered

In the above example, we used the command cat -n groceryFinal.txt where

cat represents the concat command
-n represents the option to number all output line
groceryFinal.txt represents the file to view the content of

2. tac command

The tac command which is just the reverse of cat command starts reading from bottom.

It does not change the content it just reads from the bottom.

To use tac command we simply use tac along with the "filename"

Let's just use the previously concatenated file as input for the tac command.

In the above example, we used the command tac groceryFinal.txt which printed the content of the file from bottom up.

3. rev command

The rev command is used to reverse the content of the file.

It reads the file from the top but the content will be reversed.

The syntax for rev command

To use rev command we simply use rev along with the "filename"

Let's again use our groceryFinal.txt as an input

In the above example, we used the command rev groceryFinal.txt which printed the content of the file reversed.

I can't seem to find the practical usage of rev command other than irritating someone by sending them the file after applying rev command :)

4. less command

The less command provides us a way to view text files in our terminal itself.

The syntax for opening a file using less command

To open a file using less we only need to call less command along with the filename.

less provides us tons of functionality such as search a character, scroll up/down, etc.

5. Head and Tail

head command is used to print the lines from the start of the file whereas the tail command is used to print the files from the bottom of the file.

Let's take an example for better understanding

print only the first two line from a file

In the above example, we used the command head -n 2 groceryFinal.txt where

head represents the head command
-n 2 represents the number of lines option
groceryFinal.txt represents the file we want to read

print only the last two lines from a file

tail represents the tail command
-n 2 represents the number of lines option
groceryFinal.txt represents the file we want to read

So head and the tail command is basically used to view the snippet of file content.

6. sort command

The sort command is used to sort lines of text files.

The syntax for sort command

To use sort command we simply use sort command along with options and filename

In the above example, we use the command sort groceryFinal.txt which sorts the list in ascending order.

What if we want to sort in descending order?

In the above example, we used the command sort -r groceryFinal.txt where

sort represents sort command
-r represents the reverse option
groceryFinal.txt represents the input file

Can you guess what else can we use to get the same kind of output?

sort groceryFinal.txt | tac

If you guessed the tac command you were right. We can use the tac command along with sort command convert the ascending sorted output to descending output.

But what about numbers?

Let's see what happens when we use the sort command with numbers

Wait, that seems wrong but why?

So the sort command by default compares digit by digit.

So what can we do for sorting numbers?

sort file with respect to numbers

In the above example, we used the command sort -n numbers.txt where
sort represents sort command
-n represents numeric-sort
numbers.txt represents file-to-be-sorted

sort and only return distinct values

In the above example, we used the command sort -un numbers.txt where
sort represents sort command
-un represents unique numeric-sort
numbers.txt represents file-to-be-sorted

What if we have data with multiple columns and we want to sort data on the basis of a specific column?

sort data based on column 2

In the above example, we used the command sort -k 2n employees.txt where

In the above example, we used the command sort -un numbers.txt where
sort represents sort command
-k 2n represents key i.e. column 2 numeric-sort
employees.txt represents file-to-be-sorted

This was all about Viewing and Sorting Files in the Linux System.

Please, let me know if there are any questions and suggestions on what you want us to explore next.

DEV Community: yash sugandh

Optional: Handling NullPointer Graciously

What is Optional and why was it introduced?

Where can we find Optional being used?

How do we create an Optional?

The difference between orElse() and orElseGet()

When To Use an Optional

When Not To Use an Optional

Generics In Java

What is the meaning of Generics?

ClassCastException 🎆 💥

Generic Interface

Generics Class and Generic methods

Constructor

Getters and Setters

Package Management in Linux System

How a Package System Works

Debian and Ubuntu

dkg

apt

CentOS and Fedora

rpm

yum

dnf

Changing Permissions in Linux System

Permissions in Linux System

Controlling Processes in Linux System

All about processes and how can we view them

History Command and How to Use It?

Keyboard Shortcuts For Linux Terminal

Piping in Linux System

yash sugandh ・ Jun 27 '20

Filter Commands in Linux System

fd - Best alternative to Find Command

Commands for Viewing and Sorting Files

The difference between `orElse()` and `orElseGet()`