IBAP 2022: Linux Command Lines

---

---

Introduction

Welcome. We are pleased to have you take this Introduction to bioinformatics analysis of Plasmodium falciparum genome data training with us. Before you begin, it’s important to have some foundational skills in Linux, R and few bioinformatics tools. Below you will find self-assessments for Linux and R. If you are unable to complete these, see our list of recommended resources (below) to help bring you up to speed in these areas.

Background

Humans and computers commonly interact in many different ways, such as through a keyboard and mouse, touch screen interfaces, or using speech recognition systems. The most widely used way to interact with personal computers is called a graphical user interface (GUI). With a GUI, we give instructions by clicking a mouse and using menu-driven interactions.

While the visual aid of a GUI makes it intuitive to learn, this way of delivering instructions to a computer scales very poorly. Imagine the following task: for a literature search, you have to copy the third line of one thousand text files in one thousand different directories and paste it into a single file. Using a GUI, you would not only be clicking at your desk for several hours, but you could potentially also commit an error in the process of completing this repetitive task. This is where we take advantage of the Unix shell. The Unix shell is both a command-line interface (CLI) and a scripting language, allowing such repetitive tasks to be done automatically and fast. With the proper commands, the shell can repeat tasks with or without some modification as many times as we want. Using the shell, the task in the literature example can be accomplished in seconds.

Practical Goals

• navigate to a file/directory
• create a file/directory
• check the length of a file
• chain commands together
• retrieve a set of files
• iterate over files
• run a shell script containing her pipeline

The Shell

The shell is a program where users can type commands. With the shell, it’s possible to invoke complicated programs like climate modeling software or simple commands that create an empty directory with only one line of code. The most popular Unix shell is Bash (the Bourne Again SHell, so-called because it’s derived from a shell written by Stephen Bourne). Bash is the default shell on most modern implementations of Unix and in most packages that provide Unix-like tools for Windows.

Using the shell will take some effort and some time to learn. While a GUI presents you with choices to select, CLI choices are not automatically presented to you, so you must learn a few commands like new vocabulary in a language you’re studying. However, unlike a spoken language, a small number of “words” (i.e. commands) gets you a long way, and we’ll cover those essential few today.

The grammar of a shell allows you to combine existing tools into powerful pipelines and handle large volumes of data automatically. Sequences of commands can be written into a script, improving the reproducibility of workflows.

In addition, the command line is often the easiest way to interact with remote machines and supercomputers. Familiarity with the shell is near essential to run a variety of specialized tools and resources including high-performance computing systems. As clusters and cloud computing systems become more popular for scientific data crunching, being able to interact with the shell is becoming a necessary skill. We can build on the command-line skills covered here to tackle a wide range of scientific questions and computational challenges.

Let’s get started.

First, let’s open our windows terminal by clicking on the terminal icon or from the search bar type Terminal. When the shell is first opened, you are presented with a prompt, indicating that the shell is waiting for input.

karim@fadel:~$

The shell typically uses $ as the prompt, but may use a different symbol. In the examples for this lesson, we’ll show the prompt as $. Most importantly, when typing commands, either from these lessons or from other sources, do not type the prompt, only the commands that follow it. Also note that after you type a command, you have to press the Enter key to execute it.

The prompt is followed by a text cursor, a character that indicates the position where your typing will appear. The cursor is usually a flashing or solid block, but it can also be an underscore or a pipe. You may have seen it in a text editor program, for example.

So let’s try our first command by typing ls which is short for listing. This command will list the contents of the current directory:

ls

Output

Documents   Downloads     Library     Movies      Music
Pictures      Public     Malaria_training_2022   

Your results may be slightly different depending on your operating system and how you have arranged your filesystem.

If the shell can’t find a program whose name is the command you typed, it will print an error message such as:

ks

Output

ks: command not found

This might happen if the command was mis-typed or if the program corresponding to the command is not installed.

Navigate to Files and Directories

The part of the operating system responsible for managing files and directories is called the file system. It organizes our data into files, which hold information, and directories (also called ‘folders’), which hold files or other directories.

Several commands are frequently used to create, inspect, rename, and delete files and directories. To start exploring them, we’ll go to our open shell window.

First, let’s find out where we are by running a command called pwd (which stands for ‘print working directory’).

Note: Directories are like places, at any time while we are using the shell, we are in exactly one place called our current working directory. Commands mostly read and write files in the current working directory, so knowing where you are before running a command is important.

Please, type pwd and locate where you are:

pwd

Output

/home/karim

We previously showed ls that prints the names of the files and directories in the current directory. We can make its output more comprehensible by using the -F option which tells ls to classify the output by adding a marker to file and directory names to indicate what they are:

• a trailing / indicates that this is a directory
• @ indicates a link
• * indicates an executable

Depending on your shell’s default settings, the shell might also use colors to indicate whether each entry is a file or directory.

ls -F

we can see that your home directory may contain sub-directories or files. Any names in our output that don’t have a classification symbol are plain old files.

Clearing your terminal

If your screen gets too crowded, you can clear your terminal by typing clear or using the combination key CRTL + L. You can still access previous commands using up and down arrow keys to move line-by-line, or by scrolling in your terminal.

ls has lots of other options. There are two common ways to find out how to use a command and what options it accepts — depending on your environment, you might find that only one of these ways works:

1. You can pass a --help option to the command (available on Linux and Git Bash):

ls --help

2. You can read its manual with man (available on Linux and macOS):

man ls

The --help option

Most bash commands and programs that people have written to be run from within bash, support a --help option that displays more information on how to use the command or program.

ls --help

Feel free to go through the different options and play with them.

The man command

The other way to learn about ls is to type:

man ls

This command will turn your terminal into a page with a description of the ls command and its options.

To navigate through the man pages, you may use up and down arrow to move line-by-line, or try B and Spacebar to skip up and down by a full page. To search for a character or word in the man pages, use / followed by the character or word you are searching for. Sometimes a search will result in multiple hits. If so, you can move between hits using N (for moving forward) and Shift+N (for moving backward).

To quit the man pages, press Q.

You can also use two options at the same time.

Question1: - What does the command ls do when used with the -l option? - What about if you use both the -l and the -h options?

Some of its output is about properties that we do not cover in this lesson (such as file permissions and ownership), but the rest should be useful nevertheless.

Listing in Reverse Chronological Order

By default, ls lists the contents of a directory in alphabetical order by name. The command ls -t lists items by time of last change instead of alphabetically. The command ls -r lists the contents of a directory in reverse order.

Question2: Which file is displayed last when you combine the -t and -r options? Hint: You may need to use the -l option to see the last changed dates.

Exploring Other Directories

Not only can we use ls on the current working directory, but we can use it to list the contents of a different directory. Let’s take a look at our Malaria_training_2022 directory. The argument Malaria_training_2022 tells ls that we want a listing of something other than our current working directory:

ls -F Malaria_training_2022

Note that if a directory named Malaria_training_2022 does not exist in your current working directory, this command will return an error. You have downloaded it, so typically, a Malaria_training_2022 directory exists in your home directory, which we assume is the current working directory of your bash shell.

Your output should be a list of all the files and/or sub-directories in your that directory. On many systems, the command line Malaria_training_2022 directory is the same as your GUI Malaria_training_2022. Take a look at that directory to confirm that your output is accurate.

As you may now see, using a bash shell is strongly dependent on the idea that your files are organized in a hierarchical file system. Organizing things hierarchically in this way helps us keep track of our work: it’s possible to put hundreds of files in our home directory, just as it’s possible to pile hundreds of printed papers on our desk, but it’s a self-defeating strategy.

Now that we know the Malaria_training_2022 directory is located in our home directory, we can do two things.

• First, we can look at its contents, using the same strategy as before, passing a directory name to ls:

Question 3: List the contents of the Training directory from your home.

• Second, we can actually change our location to a different directory, so we are no longer located in our home directory.

The command to change locations is cd followed by a directory name to change our working directory.
cd stands for change directory, which is a bit misleading: the command doesn’t change the directory; it changes the shell’s current working directory. In other words it changes the shell’s idea of what directory we are in. The cd command is like to double-clicking a folder in a graphical interface to get into a folder.

Let’s say we want to move to the directory we saw above. We can use the following series of commands to get there:

cd Malaria_training_2022
cd materials_day1

These commands will move us from our home directory into our Malaria_training_2022 directory, then into the materials_day1 directory. You will notice that cd doesn’t print anything. This is normal. Many shell commands will not output anything to the screen when successfully executed. But if we run pwd after it, we can see that we are now in /home/karim/Malaria_training_2022/materials_day1.

If we run ls -F without arguments now, it lists the contents of /home/karim/Malaria_training_2022/materials_day1, because that’s where we now are:

ls -F

We now know how to go down the directory tree (i.e. how to go into a sub-directory), but how do we go up (i.e. how do we leave a directory and go into its parent directory)? We might try the following:

Question 4: Try to move back to the Malaria_training_2022 directory

You get an error right! Why is this?

With our methods so far, cd can only see sub-directories inside your current directory. There are different ways to see directories above your current location; we’ll start with the simplest.

There is a shortcut in the shell to move up one directory level that looks like this:

cd ..

.. is a special directory name meaning “the directory containing this one”, or more succinctly, the parent of the current directory. Sure enough, if we run pwd after running cd .., we’re back in /home/username/Malaria_training_2022:

pwd

The special directory .. doesn’t usually show up when we run ls. If we want to display it, we can add the -a option to ls -F:

ls -F -a

-a stands for ‘show all’; it forces ls to show us file and directory names that begin with ., such as .. (which, if we’re in /home/username/, refers to the /Users directory). As you can see, it also displays another special directory that’s just called ., which means ‘the current working directory’. It may seem redundant to have a name for it, but we’ll see some uses for it soon.

Note that in most command line tools, multiple options can be combined with a single - and no spaces between the options: ls -F -a is equivalent to ls -Fa.

Other Hidden Files

In addition to the hidden directories .. and ., you may also see a file called .bash_profile in your home directory. This file usually contains shell configuration settings. You may also see other files and directories beginning with . These are usually files and directories that are used to configure different programs on your computer. The prefix . is used to prevent these configuration files from cluttering the terminal when a standard ls command is used.

These three commands are the basic commands for navigating the filesystem on your computer: pwd, ls, and cd. Let’s explore some variations on those commands. 

Question 5: What happens if you type cd on its own, without giving a directory?

Question 6: How can you check what happened?

# It turns out that `cd` without an argument will return you to your home directory, which is great if you’ve got lost in your own filesystem.

Question 7: Try returning to the materials_day1 directory from before. Last time, we used three commands, but we can actually string together the list of directories to move to materials_day1 in one step:

cd Malaria_training_2022/materials_day1

Question 8: Check that we’ve moved to the right place.

If we want to move up one level from the data directory, we could use cd ... But there is another way to move to any directory, regardless of your current location.

So far, when specifying directory names, or even a directory path (as above), we have been using relative paths. When you use a relative path with a command like ls or cd, it tries to find that location from where we are, rather than from the root of the file system.

However, it is possible to specify the absolute path to a directory by including its entire path from the root directory, which is indicated by a leading slash. The leading / tells the computer to follow the path from the root of the file system, so it always refers to exactly one directory, no matter where we are when we run the command.

This allows us to move to our Malaria_training_2022 directory from anywhere on the filesystem (including from inside materials_day1). To find the absolute path we’re looking for, we can use pwd and then extract the piece we need to move to Malaria_training_2022.

pwd

cd /home/karim/Malaria_training_2022/

Other Shortcuts

The shell interprets a tilde (~) character at the start of a path to mean “the current user’s home directory”. For example, if your home directory is /home/Username, then ~/Downloads is equivalent to /home/Username/Downloads. This only works if it is the first character in the path: here/there/~/elsewhere is not here/there/home/Username/elsewhere.

Another shortcut is the - (dash) character. cd will translate - into the previous directory I was in, which is faster than having to remember, then type, the full path. This is a very efficient way of moving back and forth between two directories – i.e. if you execute cd - twice, you end up back in the starting directory.

The difference between cd .. and cd - is that the former brings you up, while the latter brings you back.

Try it! First navigate to ~/Malaria_training_2022/ (you should already be there).

cd ~/Malaria_training_2022/

Then cd into the materials_day1 directory:

cd materials_day1

Now if you run

cd -

you’ll see you’re back in _{/Malaria_training_2022. Run cd - again and you’re back in} /Malaria_training_2022/materials_day1

Absolute vs Relative Paths

Question 9: Starting from /home/Archie/data, which of the following commands could Archie use to navigate to his home directory, which is /home/Archie?

1. cd .
2. cd /
3. cd /home/Archie
4. cd ../..
5. cd ~
6. cd home
7. cd ~/data/..
8. cd
9. cd ..

Note that the shell does most of the work through what is called tab completion. If you type the first letters of your directory name and press Tab (the tabulation key on your keyboard), the shell automatically completes the directory name for you.

However, pressing Tab again does nothing, when there are multiple possibilities; pressing Tab twice brings up a list of all the files.

Working With Files and Directories

Creating directories

Now, we know how to explore files and directories, but how do we create them in the first place?

We will learn about creating and moving files and directories, using the Malaria_training_2022 directory as an example.

Step one: see where we are and what we already have

We should still be in the Malaria_training_2022 directory, which we can check using pwd. If you’re not there, move back to that folder.

Create a directory

Let’s create a new directory called Linux using the command mkdir Linux:

mkdir Linux

As you might guess from its name, mkdir means ‘make directory’. Since Linux is a relative path (i.e., does not have a leading slash), the new directory is created in the current working directory:

ls -F

Since we’ve just created the Linux directory, there’s nothing in it yet:

ls -F Linux

Note that mkdir is not limited to creating single directories one at a time. The -p option allows mkdir to create a directory with nested sub-directories in a single operation:

mkdir -p ../training/data ../training/results

The -R option to the ls command will list all nested sub-directories within a directory. Let’s use ls -FR to recursively list the new directory hierarchy we just created in the training directory:

ls -FR ../training

Naming files and directories

Complicated names of files and directories can make your life painful when working on the command line. Here we provide a few useful tips for the names of your files and directories.

1. Don’t use spaces.

Spaces can make a name more meaningful, but since spaces are used to separate arguments on the command line it is better to avoid them in names of files and directories. You can use - or _ instead (as you can see in the workshop naming style). To test this out, try typing mkdir malaria training civ and see what directory (or directories!) are made when you check with ls -F.

# Create new directory using space in the naming
mkdir malaria training civ

# List directory
ls -F

## mkdir: cannot create directory ‘malaria’: File exists
## mkdir: cannot create directory ‘training’: File exists
## mkdir: cannot create directory ‘civ’: File exists
## civ/
## iris_data.txt
## malaria/
## session2_Lecture_command_lines.pptx
## session2_part1_unix_command_lines.html
## session2_part1_unix_command_lines.Rmd
## session2_part2_advanced_unix_command.Rmd
## session2_part3_writing_scripts_working_with_data.Rmd
## training/

What do you notice?

2. Don’t begin names with - (dash).

Commands treat names starting with - as options.

3. Stick with letters, numbers, . (period or ‘full stop’), - (dash) and _ (underscore).

Many other characters have special meanings on the command line. We will learn about some of these during this lesson. There are special characters that can cause your command to not work as expected and can even result in data loss.

If you need to refer to names of files or directories that have spaces or other special characters, you should surround the name in quotes (” “).

Create a text file

Let’s change our working directory to Linux folder we created using cd, then run a text editor called Nano to create a file called example.txt:

cd Linux
nano example.txt

Text Editor

Nano is a text editor that can only work with plain character data, not tables, images, or any other human-friendly media. We use it in examples because it is one of the least complex text editors. However, because of this trait, it may not be powerful enough or flexible enough for the work you need to do after this workshop. On Unix systems (such as Linux and macOS), many programmers use Emacs or Vim (both of which require more time to learn), or a graphical editor such as Gedit. On Windows, you may wish to use Notepad++. Windows also has a built-in editor called notepad that can be run from the command line in the same way as nano for the purposes of this session.

No matter what editor you use, you will need to know where it searches for and saves files. If you start it from the shell, it will (probably) use your current working directory as its default location. If you use your computer’s start menu, it may want to save files in your desktop or documents directory instead. You can change this by navigating to another directory the first time you ‘Save As…’

Let’s type in a few lines of text. Once you’re happy with our text, you can press Ctrl+O (press the Ctrl or Control key and, while holding it down, press the O key) to write our data to disk (you’ll be asked what file you want to save this to: press Return to accept the suggested default of example.txt).
Once our file is saved, you can use Ctrl+X to quit the editor and return to the shell.

In nano, along the bottom of the screen you’ll see ^G Get Help ^O WriteOut. This means that you can use Ctrl-G to get help and Ctrl-O to save your file.

nano doesn’t leave any output on the screen after it exits, but ls now shows that you have created a file called example.txt.

A Different Way for Creating Files

We have seen how to create text files using the nano editor. Now, try the following command:

touch my_file.txt

Question 10: What did the touch command do? When you look at your current directory using the GUI file explorer, does the file show up?

Question 11: Use ls -l to inspect the files. How large is my_file.txt?

Question 12: When might you want to create a file this way?

Removing Files / Directories

You might create a lot of files and directories in a process of analyzing data. What if you want to get rid of them? This is actually quite an important skill and one that is often overlooked. When you work with lots of data, getting rid of files you don’t need is very, very important. Cluttered directories are an absolute nightmare to deal with.

You can easily remove files with the rm command. For instance, let’s remove the file you’ve just created before proceeding with the rest of the session, otherwise future outputs may vary from those given in the lesson. To do this, you can use the following command:

rm my_file.txt

We could also use this following command:

rm -i my_file.txt

Here, there is a flag after rm -i which simply tells the command to ask permission before deleting. Indeed, when you run the command above, you will receive a prompt asking you if you really want to delete a file. We will see later on how to remove multiple files and directories.

Moving files and directories

Let’s move back to our Malaria_training_2022/ directory,

cd ~/Malaria_training_2022/

In our training directory, we have a file example.txt which isn’t a particularly informative name, so let’s change the file’s name using mv, which is short for ‘move’:

mv Linux/example.txt Linux/commands.txt

The first argument tells mv what we’re ‘moving’, while the second is where it’s to go. In this case, we’re moving Linux/example.txt to Linux/commands.txt, which has the same effect as renaming the file. Sure enough, ls shows us that Linux now contains one file called commands.txt

ls Linux

One must be careful when specifying the target file name, since mv will silently overwrite any existing file with the same name, which could lead to data loss. An additional option, mv -i (or mv –interactive), can be used to make mv ask you for confirmation before overwriting.

Note that mv also works on directories.

Let’s move commands.txt into the current working directory. We use mv once again, but this time we’ll use just the name of a directory as the second argument to tell mv that we want to keep the filename but put the file somewhere new. (This is why the command is called ‘move’.) In this case, the directory name we use is the special directory name that we mentioned earlier.

mv Linux/commands.txt .

The effect is to move the file from the directory it was in to the current working directory. ls now shows us that Linux is empty:

ls Linux

Alternatively, we can confirm the file commands.txt is no longer present in the Linux directory by explicitly trying to list it:

ls Linux/commands.txt

ls with a filename or directory as an argument only lists the requested file or directory. If the file given as the argument doesn’t exist, the shell returns an error as we saw above. We can use this to see that commands.txt is now present in our current directory:

ls commands.txt

Copying files and directories

The cp command works very much like mv, except it copies a file instead of moving it. We can check that it did the right thing using ls with two paths as arguments — like most Unix commands, ls can be given multiple paths at once:

cp commands.txt Linux/linux_commands.txt
ls commands.txt Linux/linux_commands.txt

We can also copy a directory and all its contents by using the recursive option -r, e.g. to back up a directory:

cp -r Linux Linux_backup

We can check the result by listing the contents of both the Linux and Linux_backup directory:

ls Linux Linux_backup

Renaming Files

Suppose that you created a plain-text file in your current directory to contain a list of the statistical tests you will need to do to analyze your data, and named it: statstics.txt

Question 13: After creating and saving this file you realize you misspelled the filename! You want to correct the mistake, which of the following commands could you use to do so?

1. cp statstics.txt statistics.txt
2. mv statstics.txt statistics.txt
3. mv statstics.txt .
4. cp statstics.txt .

Moving and Copying

Question 14: What is the output of the closing ls command in the sequence shown below?

pwd

Output

/Users/tony/data

ls

Output

proteins.fasta

mkdir recombined
mv proteins.fasta recombined/
cp recombined/proteins.fasta ../proteins-saved.fasta
ls

Answer

1. proteins-saved.fasta recombined
2. recombined
3. proteins.fasta recombined
4. proteins-saved.fasta

Removing files and directories

Returning to the Malaria_training_2022/ directory, let’s tidy up this directory by removing the commands.txt file we created. The Unix command we’ll use for this is rm (short for ‘remove’):

rm commands.txt

We can confirm the file has gone using ls:

ls commands.txt

The Unix shell doesn’t have a trash bin that we can recover deleted files from (though most graphical interfaces to Unix do). Instead, when we delete files, they are unlinked from the file system so that their storage space on disk can be recycled. Tools for finding and recovering deleted files do exist, but there’s no guarantee they’ll work in any particular situation, since the computer may recycle the file’s disk space right away.

Question 15: What happens when we execute rm -i Linux_backup/linux_commands.txt? Why would we want this protection when using rm?

Now, try to remove the Linux directory using rm Linux and see what will happen:

rm Linux

This happens because rm by default only works on files, not directories.

rm can remove a directory and all its contents if we use the recursive option -r, and it will do so without any confirmation prompts:

rm -r Linux

Given that there is no way to retrieve files deleted using the shell, rm -r should be used with great caution (you might consider adding the interactive option rm -r -i).