A common practice in software projects is to keep certain information separated but accessible from the codebase which uses it. Developers usually do this with secrets such as passwords or private keys, or with user or context-specific info pieces.

But managing environment variables can be a pain. There are a number of solutions to ease that pain, and there are even built-in ones such as bash_profile.

One solution I've discovered recently and found particularly convenient is direnv. It's a shell extension which lets you define environment variables scoped by directory.

After installing and hooking the extension to your shell, direnv will execute every time you change directories, looking for an .envrc file in the same or in a superior directory tree level. It will then load the defined variables to the current environment, and unload them if it ceases to detect the same .envrc.

Note that direnv will load the first detected .envrc file, which means that the environment will not inherit values from a .envrc in a parent directory.

It is also important to keep in mind that the environment variables will only be loaded to your shell session once you move to a directory affected by a .envrc file. So if you try something like running a script which loads an environment defined in a directory below your current level, the variables won't be accessible.

How to Install direnv

Here's a list of supported systems. It is very likely that your UNIX-based system's main open source package manager has it available.

Suppose we are on Debian, we can install direnv by running the standard external package install command in the terminal:

sudo apt-get install direnv

How to Setup direnv

After you install it, you need to hook direnv to your shell. If you're using bash, you can do this by appending this line to the end of your shell startup config file:

echo 'eval "$(direnv hook bash)"' >> ~/.bashrc

It's almost the same for ZShell:

echo 'eval "$(direnv hook zsh)"' >> ~/.zshrc

Direnv also supports FISH, TCSH, and Elvish. Here are the hooking instructions for each supported shell.

How to Use direnv

Now we must create an .envrc file for the directory we would like to scope the environment variables to.

Say we create it for the directory ~/project.

echo export FOO='I love Linux!' >> ~/project/.envrc

You will then receive a warning that the current .envrc wasn't read. direnv will block loading .envrc every time it detects changes which were not explicitly allowed. So now run:

direnv allow ~/project

and voilà!, you now have a directory-scoped environment.

Remember when I told you that 'direnv will block loading .envrc every time it detects changes which were not explicitly allowed'? This isn't limited to newly introduced changes – the whole file will be unauthorized. So when you do this:

echo export BAR='It is actually called GNU/Linux!' >> ~/project/.envrc

you will have to run direnv allow ~/project again, even to access $FOO. Kinda boring, but biased towards safety.

Every time an .envrc is loaded, direnv will output a message with the file path and also the names of the variables loaded, so you don't need to worry about forgetting your setup. It will also tell you whenever an environment was unloaded.

Thanks for reading!

That's it! It's pretty straightforward, and I hope you find it as convenient as I did.

Let's get started!

What is the awk command?

awk is a scripting language, and it is helpful when working in the command line. It's also a widely used command for text processing.

When using awk, you are able to select data – one or more pieces of individual text – based on a pattern you provide.

For example, some of the operations you can do with awk are searching for a specific word or pattern in a piece of text given, or even select a certain line or a certain column in a file you provide.

The Basic Syntax of the awk command

In its simplest form, the awk command is followed by a set of single quotation marks and a set of curly braces, with the name of the file you want to search through mentioned last.

It looks something like this:

awk '{action}' your_file_name.txt

When you want to search for text that has a specific pattern or you're looking for a specific word in the text, the command would look something like this:

awk '/regex pattern/{action}' your_file_name.txt

How to create a sample file

To create a file in the command line, you use the touch command. For example: touch filename.txt where filename, is the name of your file.

You can then use the open command (open filename.txt), and a word processor program like TextEdit will open where you can add the contents of the file.

So, say you have a text file, information.txt, that contains data separated into different columns.

The file contents could look something like this:

fristName       lastName        age     city       ID

Thomas          Shelby          30      Rio        400
Omega           Night           45      Ontario    600
Wood            Tinker          54      Lisbon     N/A
Giorgos         Georgiou        35      London     300
Timmy           Turner          32      Berlin     N/A

In my example, there is one column for firstName, lastName, age, city, and ID.

At any time, you can view the output of the contents of your file by typing cat text_file, where text_file is the name of your file.

How to print all the contents of the file using awk

To print all the contents of a file, the action you specify inside the curly braces is print $0.

This will work in exactly the same way as the cat command mentioned previously.

awk '{print $0}' information.txt

Ouptut:

fristName       lastName        age     city       ID

Thomas          Shelby          30      Rio        400
Omega           Night           45      Ontario    600
Wood            Tinker          54      Lisbon     N/A
Giorgos         Georgiou        35      London     300
Timmy           Turner          32      Berlin     N/A

If you would like each line to have a line-number count, you would use the NR built-in variable:

awk '{print NR,$0}' information.txt

1 fristName     lastName        age     city       ID
2 
3 Thomas        Shelby          30      Rio        400
4 Omega         Night           45      Ontario    600
5 Wood          Tinker          54      Lisbon     N/A
6 Giorgos       Georgiou        35      London     300
7 Timmy         Turner          32      Berlin     N/A

How to print specific columns using awk

When using awk, you can specify certain columns you want printed.

To have the first column printed, you use the command:

awk '{print $1}' information.txt

Ouput:

Thomas
Omega
Wood
Giorgos
Timmy

The $1 stands for the first field, in this case the first column.

To print the second column,you would use $2:

awk '{print $2}' information.txt

Output:

lastName

Shelby
Night
Tinker
Georgiou
Turner

The way awk determines where each column starts and ends is with a space, by default.

To print more than one column, for example the first and forth columns, you would do:

awk '{print $1, $4}' information.txt

Ouput:

fristName city

Thomas    Rio
Omega     Ontario
Wood      Lisbon
Giorgos   London
Timmy     Berlin

The $1 represents the first input field (first column), and the $4 represents the forth. You separate them with a comma, $1,$4, so the output has a space and is more readable.

To print the last field (the last column), you can also use $NF which represents the last field in a record:

awk '{print $NF}' information.txt

Output:

ID

400
600
N/A
300
N/A

How to print specific lines of a column

You can also specify the line you want printed from your chosen column:

awk '{print $1}' information.txt | head -1

Ouput:

FirstName

Let's break that command down. awk '{print $1}' information.txt prints the first column. Then the output of that command (which you saw earlier on) is piped, using the pipe symbol |, to the head command, where its -1 argument selects the first line of the column.

If you wanted two lines printed, you'd do:

awk '{print $1}' information.txt | head -2

Output:

FirstName
Dionysia

How to print out lines with a specific pattern in awk

You can print a line that starts with a specific letter.

For example:

awk '/^O/' information.txt

Output:

Omega           Night           45      Ontario    600

That command selects any line with text that starts with an O.

You use the up arrow symbol (^) first, which indicates the beginning of a line, and then the letter you want a line to start with.

You can also print a line that ends in a specific pattern:

awk '/0$/' information.txt

Output:

Thomas          Shelby          30      Rio        400
Omega           Night           45      Ontario    600
Giorgos         Georgiou        35      London     300

This prints out the lines that end in a 0 – the $ symbol is used after a character to siginify how a line will end.

That command could also be changed to:

awk '! /0$/' information.txt

The ! is used as a NOT, so in this case it selects the lines that DON'T end in a 0.

fristName       lastName        age     city       ID

Wood            Tinker          54      Lisbon     N/A
Timmy           Turner          32      Berlin     N/A

How to use regular expressions in awk

To output words that contain certain letters and print out words that match a pattern you specify, you again use the slashes, //, shown previously.

If you want to look for words containing on, you'd do:

awk ' /io/{print $0}' information.txt

Output:

Thomas          Shelby          30      Rio        400
Omega           Night           45      Ontario    600
Giorgos         Georgiou        35      London     300

This matches all entries that contain io.

Say you had an extra column – a department column:

fristName       lastName        age     city       ID   department

Thomas          Shelby          30      Rio        400  IT
Omega           Night           45      Ontario    600  Design
Wood            Tinker          54      Lisbon     N/A  IT
Giorgos         Georgiou        35      London     300  Data
Timmy           Turner          32      Berlin     N/A  Engineering

To find all the information of people working in IT, you would need to speficy the string you're searching for between the slashes, //:

awk '/IT/' information.txt

Output:

Thomas          Shelby          30      Rio        400  IT
Wood            Tinker          54      Lisbon     N/A  IT

What if you wanted to see only the first and last names of the people working in IT?

You can specify the column like such:

awk '/IT/{print $1, $2}' information.txt

Output:

Thomas Shelby
Wood   Tinker

This will only display the first and second columns where IT appears, instead of presenting all fields.

When searching for words with a specific pattern, there may be times when you'll need to use an escape character, like such:

awk '/N\/A$/' information.txt

Output:

Wood            Tinker          54      Lisbon     N/A
Timmy           Turner          32      Berlin     N/A

I wanted to find lines that end with the pattern N/A.

So, when searching between the ' // ' like shown so far, I had to use an escape character (\) between N/A, otherwise I would've gotten an error.

How to use comparisson operators in awk

If, for example, you wanted to find all the information of employees that were under the age of 40, you would use the < comparisson operator like so:

awk '$3 <  40 { print $0 }' information.txt

Output:

Thomas          Shelby          30      Rio        400
Giorgos         Georgiou        35      London     300
Timmy           Turner          32      Berlin     N/A

The output shows only the information of people under 40.

Conclusion

And there you have it! You now know the absolute basics to start working with awk and manipulate text data.

To learn more about Linux, freeCodeCamp has a wide variety of learning materials available.

Here are a couple of them get you started:

• Linux Basics - Hands-On Workshop
• Linux for Ethical Hackers (Kali Linux Tutorial)
• The Linux Command Handbook

Thanks for reading and happy learning 😊

Now, if you are active on social media platforms and developer forums you might have come across Twitter polls and endless discussions on platforms like Reddit, StackOverflow, and others. We haven't come up with a solid answer yet because everybody has their own opinion.

I will promise you one thing here – we won't be answering this question in this article, as trying to answer this question is similar to answering which is the best laptop for a developer to use – we all have different preferencese, right?

But what this article will do is discuss questions like:

• What is an operating system?
• The history of operating systems
• How an operating system works
• Types and examples of operating systems
• Functions of an operating system
• Why you need an operating system

By answering these questions hopefully you will be in a position to choose the right operating system for your needs. You'll also understand the basics of how an operating system works, and that will be the best OS for you as a developer.

Let's get started:

What is an Operating System?

The recent advancements in technologies, where every gadget is considered a smart device has really revolutionized the world. Almost everyone has access to this devices be it mobile phones, tablets, laptops, smart watches or even your personal computer at home. Also to add to the list the huge rising number of the modern vehicles.

What all the above mentioned have in common is, they use an operating system to enable their functionality for you to achieve a certain task. Despite all this amazing being owned by us, very few of us get to understand how the OS that makes it possible to achieve different tasks is structured.

With this understanding we can describe an Operating System(OS) as a software that manages computer hardware and software resources and provides common services for computer programs.

In simple English we can say an OS is an interface between the user and the machine that makes it easy for the user to achieve different tasks with ease.

Now you have an understanding of what an OS is and also a slight idea of what it does, So! how did it all come into existence, where did it all begin? Let's have a look at it's history

History of Operating Systems

It all began back in the 1950s, when computer could only handle one program at a go. During this period users directly interacted with the computer hardware. For a program to be executed it was loaded in an input device like a card reader before execution could begin, and incase of an error during execution the registers and main memory had to be inspected to determine the cause of the error.

When the first operating system was developed by General Motors in 1956 it came as a huge success in the market. It's main purpose was to run a single IBM central computer. Due to it's success, IBM took it forward and became the first company to develop operating systems and began distributing them.

In the 1960s the Bell labs introduced the first version of the Unix OS, it was the first system that could support multi-tasking and multi-user functionality. This system was written in C programming language and was freely available. It was widely accepted and adapted by many users this led to it's official release of the first version in the 70s.

With it's success on early stages it was widely accepted, which led to many operating systems used today borrow their origin from them. Some of the companies with their origin from UNIX include: Mac OS X, iOS, Android, Chrome OS etc...

1977 Apple Dos was introduced in the market. It was designed for home computers and it was a huge success. The designer of this OS was Steve Wozniak. Originally it was designed as a ROM, but in 1978 a first DOS was commissioned and it became a popular software.

Microsoft came into play in the year 1981, where they introduced MS-DOS. After it's launch it was shipped and used for the IBM personal computers. Later on in 1990 Windows 3.0 was launched, this became a rival to Apple's Macintosh GUI.

1992 Windows 3.1x was launched. This operating system introduced several enhancements like improvement in multimedia support and system usability just to list a few. Over the years Microsoft continued to improve their system with betterment from the user's side. The improvement has been seen long way till the recent system we have which is Windows 11.

In March 2008 Apple introduced iPhone OS 1, which was the first iOS for Apple's mobile OS. When the iPhone software development kit (iPhone SDK) was released, the operating system previously known as iPhone OS was later renamed to iOS.

Android OS was released on September 2008. It was developed by Google based on Linux Kernel. By this time Android became the first competitor iOS.

Today Apple, OS X, Windows and various forms of Linux dominate the market of the modern Operating System.

How an Operating System Works

The work-flow of a computer begins when you press the power button on your PC or even your phone. Once the power button is pressed the OS is the first program that runs.

In a real real-life scenario we can compare an OS to the government in a particular country. Just like the way governments offer different directives on services and regulations to run different departments the same way OS controls program executions in a machine.

Another scenario to describe this: If you were to travel to a place that you had never been to before, where they speak a language that you are not familiar with, how will you communicate with the locals? Obviously yo will need a translators help. That's exactly what an OS does in your computer. It converts the computer language into a human understandable language.

Without the help of an OS it will be difficult to run even a single program in a machine actually it will be very complex to execute a single task. With this simple understanding you are able to understand that one of the OS's role is to organize and control hardware and software so that the device it lives in does not only behave in a flexible but also predictable way.

Types of Operating Systems

Operating Systems is one of the softwares that have been constantly updated over the past years. Different companies continuously working to provide best of their product to keep up with competitors.

They Include:

1. Real-time Operating System

The main aim of this system is executing real-time applications. It gives the maximum time for each of the critical operations that it performs. As a result, it guarantees the events will be processed in a given time.

This OS uses a specialized scheduling algorithms, this is to ensure that it switches tasks according to their priorities so that the deadlines are met for every task.

Some of the commonly known real-time OS include Windows CE, OS-9, and Symbian. Some common application of real-time include air traffic control systems, weapons control systems, industrial control systems, and control machinery.

2. Multi-programming Operating System

They are also known as Multi-tasking OS. They are divided into two parts: pre-emptive and co-operative.

In pre-emptive the OS divides the CPU time and dedicates a slot to each of the assigned programs. It is similar to the multi-threading. On the other hand Cooperative is achieved by depending on each process to give time to the other processes in a defined manner. It is similar to block multi-threading.

The main goal in multiprogramming operating systems is to improve resource utilization and system throughput and this is achieved through organizing the computing jobs in a manner that ensures that the CPU always has a job to execute at any one time.

3. Batch Operating System

The execution of programs is done in batches. Programs are collected, grouped and scheduled for later processing. This ensures faster processing speed for the programs.

Some problems associated with these operating systems include the lack of interaction between the user and the computer, difficulty in prioritizing tasks based on their urgency, and high CPU idle time caused by the low speed of the mechanical input and output devices. A good example of this system is the IBM's z/OS.

4. Distributed Operating System

This is OS manages a group of independent machines and makes them appear as a single computer. They use powerful micro-processors that take advantage of the advancement in networking.

Distributed operating systems also ensure that there is a lighter load on the host machine even when performing heavy computations. A group of computers together in a cooperation form a distributed system.

Examples of Operating Systems

Different types of OS means that we will have specific examples for each. Tech companies compete on daily basis to meet their customer's needs be it users of mobile phones, Desktops, laptops or the smart gadgets we have.

Below is a list of the most popular computer and smart-phone operating systems in the market today.

Computer OS

Microsoft Windows Developed by Microsoft, It is the most used OS among computer users. It's latest release is Windows 11, with some of it's older versions include: Windows 10, 8.1, 8, 7, Vista. XP and Windows 2000.

To install it you will need to purchase a copy of the software which is accompanied by a uniques product activation key.

Mac OS Developed by Apple for Apple computers. This OS comes pre-installed in all Macintosh computers.

Linux It is an Open-Source software, which has resulted to many distributions over the past years. It is considered to be used by people who know their way around working with the command line.

Some of it's distributions include: Ubuntu, Parrot, Debian, Arch, Linux Mint, Fedora, Kali Linux, and more.

Other rising OS among computer field include: Chrome OS & Android

Smart-phone OS

Some of the most popular include: Android, Apple iOS, Windows Mobile, Blackberry OS, Palm OS, Google pixel and Symbian OS.

Functions of an Operating System

Speaking of OS functions, has it ever crossed your mind how the computer manages to handle different processes, how different tasks are managed or even implemented?

If this questions have ever crossed your mind, then in this section they will be answered, all this are functions that are being handled by the OS, Let's talk more about the same below:

1. Memory Management It's the work of the OS to manage the computer memory. With the help of the CPU the OS keeps track of the memory used by a particular program, It will be fair to mention that the OS ensures that each program is allocated enough memory to execute it's process

2. Process Management The OS is responsible for deciding the order in which processes will be executed, this act is known as process scheduling. Process management is made possible with the help of algorithms. Other responsibilities that lie under this category include: keeping status of a process and ensuring each process receives enough time to execute.

3. Device Management It monitors all devices connected to your device, both the input and output devices. It's main function is to ensure that all the connected devices are correctly allocated and function. It also decides which process gets access to a certain device and for how long.

4. File Management As we all know a system do contain multiple and large amount of data. It's the work of the OS to keep track of all this information including their location, accessibility rights, where they are stored, status of the file. It also manages the process of file deletion.

5. Job Scheduling The operating system determines the jobs/tasks that need to be processed first and ensures that these tasks are completed. Usually the one with the highest priority is executed first. It also keeps track of the time and resources used by various tasks and users.

6. Error Detection & Response When a computer is running we are bount to encounter a number of errors, by the computer being able to indicate or show you where this is made possible with the help of the OS. The OS offers helps by a response that guides you on what to do next.

Advantages and Disadvantages of Operating Systems

By this point it is evident that OS plays a big role in our day to day life. It is within our midist either your phone or even you laptop or the PC back at the office.

With the different types we have they all have their benefits and downsides, that's why there will always be new versions released time after time. Let's have a look at some of the pros and cons of an OS.

Advantages

1. Resource Sharing Operating System allows for an opportunity to share resources with other users via services like printers, fax, over the network etc... some of the most commonly shared resources include: files documents, videos, images and apps, mails.

2. Security With the large amount of data stored in the computers it's the responsibility of an OS to make sure all the data present is secure. A good example of an OS actively securing user data is the Microsoft's Windows Defender, it detects malicious and harmful files and removes them or denies access to install.

3. User Friendly The interface provided by the GUI is much more user friendly compared to a command line interface. It comes with various symbols, buttons, menus and other graphical representations which all make them easily understandable. As a result, users can interact and communicate with the machine easily.

4. Multitasking By using an operating system, users can perform different tasks simultaneously. There is no need to close one window to open another.

Disadvantages

1. Cost Unless it is an open-source operating system like Linux and it's distros, most Operating Systems are considered to be expensive. Even though users can choose free versions of them, they typically have limited features.

2. Virus Attacks Just like any other software out there, the risk of viruses is always higher in an operating system. Sometimes users can unknowingly download malicious programs, visit malicious websites, or open email attachments containing viruses, all which can make a computer vulnerable to viruses.

3. Complexity The languages used to develop the OS are more complex for people without programming knowledge. So you can't always quickly resolve problems in the OS just by looking you will have to look for a specialist to help hence maintenance cost rises.

4. System Failure An operating system is the heart of the computer system, and if by any chance, due to any reason, it stops functioning, then the whole system will crash. Meaning without an OS your machine can not function at all.

How to Choose an Operating System

By knowing what to look for when choosing an OS, will have a big impact on your daily interaction with computer. It is always advised to shop keeping in mind the budget at hand and the features you are aspiring for this also depends with your career.

Here are the common actors to consider:

1. User-friendliness Each OS has a new thing it has to offer, especially for the beginners. Be sure the OS you choose has an easier learning curve and you can easily adapt to it. Linux and it's distributions have always been considered less user friendly to beginners with OS like windows being more friendly.

2. Software Compatibility Be sure to chore an OS that supports installation of the softwares you use on daily basis or even plan to use. A good example is windows system supports a wide variety of commercial softwares unlike Mac which mostly supports softwares from it's library only.

3. Hardware Configuration You'll want to make sure that you'll have access to the software that you use in service delivery. You just need the software that will help you deliver your services. Pick the operating system that has everything that you need with full support and updates.

4. Cost & Support You will need to make sure that the price range is within your budget. Mac generally costs more than most of the others. It is possible to get a cheaper or free OS that effectively serves every purpose you'll need it to serve.

5. Security As discussed from the disadvantages since an OS is just like any other software it's vulnerable to attacks. Be sure to choose an OS that has high security measures. Usually Windows is considered to be more vulnerable due to it's wide market share while Linux distros are considered less vulnerable

Wrap Up

Perhaps you are still wondering what people's take is on the longest debate about the OS best for developers, well according to many surveys and polls conducted by different organizations windows has always managed to scope the top position:

According to the latest Stack Overflow survey, over 80,000 developers were asked that same question. and here is the overall say:

There you have it, all the knowledge you require to help you get around the OS topic, having said this hope this article has helped you out and if you are a beginner all the best as you find the best OS for your work.

Enjoy coding ❤.

To copy files or directories in Unix-based operating systems (Linux and MacOS), you use the cp command.

The cp command is a relatively simple command, but its behavior changes slightly depending on the inputs (files vs directories) and the options you pass to it.

To view the documentation or manual for the cp command, run man cp at your terminal:

$ man cp

NAME
     cp -- copy files

SYNOPSIS
     cp [OPTIONS] source_file target_file
     cp [OPTIONS] source_file ... target_directory

...

The basic form of this command takes an input source (or sources) that you want to copy (files or directories) and a destination to copy the files or directories to:

cp [OPTIONS] source_file target_file

How to copy a file to the current directory

To copy a file, pass the file you want to copy and the path of where you want to copy the file to.

If you have a file named a.txt, and you want a copy of that file named b.txt:

$ ls
a.txt

$ cp a.txt b.txt

$ ls
a.txt   b.txt

If you're not familiar with the ls command, ls "lists" all the contents of a directory.

By default the cp command uses your current directory as the path.

How to copy a file to another directory

To copy a file to a directory that is different from your current directory, you just need to pass the path of the other directory as the destination:

$ ls ../directory-1/

$ cp a.txt ../directory-1/

$ ls ../directory-1/
a.txt

After the cp command, the previously empty directory-1 now contains the file a.txt.

By default the copied file receives the name of the original file, but you can also optionally pass a file name as well:

$ cp a.txt ../directory-1/b.txt

$ ls ../directory-1/
b.txt

How to copy multiple files to a directory

To copy more than one file at a time you can pass multiple input sources and a directory as destination:

$ ls ../directory-1/

$ cp first.txt second.txt ../directory-1/

$ ls ../directory-1/
first.txt       second.txt

Here the two input sources (first.txt and second.txt) were both copied to the directory directory-1.

Note: when passing multiple sources the last argument must be a directory.

How to copy a directory to another directory

If you try to pass a directory as the input source, you get this error:

$ cp directory-1 directory-2
cp: directory-1 is a directory (not copied).

To copy a directory, you need to add the -r (or -R) flag—which is shorthand for --recursive:

$ ls directory-1
a.txt

$ cp -r directory-1 directory-2

$ ls
directory-1          directory-2

$ ls directory-2
a.txt

Here directory-1 containing the file a.txt is copied to a new directory called directory-2—which now also contains the file a.txt.

How to copy the entire directory vs the contents of the directory

There is an interesting edge case when you copy a directory: if the destination directory already exists, you can choose whether to copy the contents of the directory or the entire directory by adding or removing a trailing / from your input.

Here's the description from the -R option of the man page:

If source_file designates a directory, cp copies the directory and the entire subtree connected at that point. If the source_file ends in a /, the contents of the directory are copied rather than the directory itself.

If you want to copy just the contents of the directory into another directory, add a trailing / to your input.

If you want to copy the contents of the directory and the directory folder itself into another directory, don't add a trailing /:

$ ls
directory-1          directory-2

$ ls directory-2

$ cp -r directory-1 directory-2

$ ls directory-2
directory-1

$ ls directory-2/directory-1
a.txt

Here you can see that because directory-2 already exists—and the input source didn't have a trailing /—both the contents of directory-1 and the directory itself was copied into the destination.

How to prevent overwriting files with cp

By default, the cp command will overwrite existing files:

$ cat a.txt
A

$ cat directory-1/a.txt
B

$ cp a.txt directory-1/a.txt

$ cat directory-1/a.txt
A

If you're not familiar with the cat or "concatenate" command, it prints the contents of a file.

There are two ways to prevent this.

The interactive flag

To be prompted when an overwrite is about to occur, you can add the -i or --interactive flag:

$ cp -i a.txt directory-1/a.txt
overwrite directory-1/a.txt? (y/n [n])

The no-clobber flag

Or, to prevent overwrites without being prompted, you can add the -n or --no-clobber flag:

$ cat a.txt
A

$ cat directory-1/a.txt
B

$ cp -n a.txt directory-1/a.txt

$ cat directory-1/a.txt
B

Here you can see that thanks to the -n flag the contents of directory-1/a.txt were not overwritten.

Other options

There are many other useful options to pass to the cp command: like -v for "verbose" output or -f for "force."

I highly encourage you to read through the man page for all of the other useful options.

If you liked this tutorial, I also talk about topics like this on Twitter, and write about them on my site.

Customizing your .bashrc file can greatly improve your workflow and increase your productivity.

The .bashrc is a standard file located in your Linux home directory. In this article I will show you useful .bashrc options, aliases, functions, and more.

The main benefits of configuring the .bashrc file are:

• Adding aliases allows you to type commands faster, saving you time.
• Adding functions allows you to save and rerun complex code.
• It displays useful system information.
• It customizes the Bash prompt.

How to Get Started with Editing .bashrc

Here's how you can edit the .bashrc file with a text editor:

$ vim ~/.bashrc

You can add date and time formatting to bash history.

HISTTIMEFORMAT="%F %T "

# Output

$ history
 1017  20210228 10:51:28  uptime
 1019  20210228 10:52:42  free -m
 1020  20210228 10:52:49  tree --dirsfirst -F
 1018  20210228 10:51:38  xrandr | awk '/\*/{print $1}'

Add this line to ignore duplicate commands in the history.

HISTCONTROL=ignoredups

To set the number of lines in active history and to set the number of lines saved in Bash history, add these two lines.

HISTSIZE=2000
HISTFILESIZE=2000

You can set your history to append instead of overwriting Bash history. shopt stands for "shell options".

shopt -s histappend

To see all the default shell options, run shopt -p.

# Output

$ shopt -p

shopt -u autocd                   
shopt -u assoc_expand_once        
shopt -u cdable_vars              
shopt -u cdspell                  
shopt -u checkhash                
shopt -u checkjobs                
shopt -s checkwinsize             
[...]

Create some variables to add color to the Bash prompt like this:

blk='\[\033[01;30m\]'   # Black
red='\[\033[01;31m\]'   # Red
grn='\[\033[01;32m\]'   # Green
ylw='\[\033[01;33m\]'   # Yellow
blu='\[\033[01;34m\]'   # Blue
pur='\[\033[01;35m\]'   # Purple
cyn='\[\033[01;36m\]'   # Cyan
wht='\[\033[01;37m\]'   # White
clr='\[\033[00m\]'      # Reset

This is for the Vim lovers. This will allow you to use vim commands on the command line. This is always the first line I add to my .bashrc.

set -o vi

How to Create Aliases in .bashrc

You can use aliases for commands you run a lot. Creating aliases will allow you to type faster, saving time and increasing productivity.

The syntax for creating an alias is alias <my_alias>='longer command'. To find out which commands would make good aliases, run this command to see a list of the top 10 commands you run most.

$ history | awk '{cmd[$2]++} END {for(elem in cmd) {print cmd[elem] " " elem}}' | sort -n -r | head -10

# Output

171 git
108 cd
62 vim
51 python3
38 history
32 exit
30 clear
28 tmux
28 tree
27 ls

Since I use Git a lot, that would be a great command to create an alias for.

# View Git status.
alias gs='git status'

# Add a file to Git.
alias ga='git add'

# Add all files to Git.
alias gaa='git add --all'

# Commit changes to the code.
alias gc='git commit'

# View the Git log.
alias gl='git log --oneline'

# Create a new Git branch and move to the new branch at the same time. 
alias gb='git checkout -b'

# View the difference.
alias gd='git diff'

Here are some other useful aliases:

# Move to the parent folder.
alias ..='cd ..;pwd'

# Move up two parent folders.
alias ...='cd ../..;pwd'

# Move up three parent folders.
alias ....='cd ../../..;pwd'

# Press c to clear the terminal screen.
alias c='clear'

# Press h to view the bash history.
alias h='history'

# Display the directory structure better.
alias tree='tree --dirsfirst -F'

# Make a directory and all parent directories with verbosity.
alias mkdir='mkdir -p -v'

# View the calender by typing the first three letters of the month.

alias jan='cal -m 01'
alias feb='cal -m 02'
alias mar='cal -m 03'
alias apr='cal -m 04'
alias may='cal -m 05'
alias jun='cal -m 06'
alias jul='cal -m 07'
alias aug='cal -m 08'
alias sep='cal -m 09'
alias oct='cal -m 10'
alias nov='cal -m 11'
alias dec='cal -m 12'

# Output

$ mar

     March 2021      
Su Mo Tu We Th Fr Sa 
    1  2  3  4  5  6 
 7  8  9 10 11 12 13 
14 15 16 17 18 19 20 
21 22 23 24 25 26 27 
28 29 30 31

How to Use Functions in .bashrc

Functions are great for more complicated code when an alias won't work.

Here's the basic function syntax:

function funct_name() {
    # code;
}

This is how you can find the largest files in a directory:

function find_largest_files() {
    du -h -x -s -- * | sort -r -h | head -20;
}

# Output

Downloads $ find_largest_files

709M    systemrescue-8.00-amd64.iso
337M    debian-10.8.0-amd64-netinst.iso
9.1M    weather-icons-master.zip
6.3M    Hack-font.zip
3.9M    city.list.json.gz
2.8M    dvdrental.tar
708K    IMG_2600.JPG
100K    sql_cheat_sheet_pgsql.pdf
4.0K    repeating-a-string.txt
4.0K    heart.svg
4.0K    Fedora-Workstation-33-1.2-x86_64-CHECKSUM
[...]

You can also add colors to the Bash prompt and display the current Git branch like this:

# Display the current Git branch in the Bash prompt.

function git_branch() {
    if [ -d .git ] ; then
        printf "%s" "($(git branch 2> /dev/null | awk '/\*/{print $2}'))";
    fi
}

# Set the prompt.

function bash_prompt(){
    PS1='${debian_chroot:+($debian_chroot)}'${blu}'$(git_branch)'${pur}' \W'${grn}' \$ '${clr}
}

bash_prompt

Custom Bash prompt

Grep (search) through your history for previous run commands:

function hg() {
    history | grep "$1";
}

# Output

$ hg vim

305  2021-03-02 16:47:33 vim .bashrc
307  2021-03-02 17:17:09 vim .tmux.conf

This is how you start a new project with Git:

function git_init() {
    if [ -z "$1" ]; then
        printf "%s\n" "Please provide a directory name.";
    else
        mkdir "$1";
        builtin cd "$1";
        pwd;
        git init;
        touch readme.md .gitignore LICENSE;
        echo "# $(basename $PWD)" >> readme.md
    fi
}

# Output

$ git_init my_project

/home/brandon/my_project
Initialized empty Git repository in /home/brandon/my_project/.git/

You can also get the weather report on the command line. This requires the package curl, jq, and an API key from Openweathermap. Read the Openweathermap API documentation in order to configure the URL correctly to get the weather in your location.

Install curl and jq with these commands:

$ sudo apt install curl jq

# OR

$ sudo dnf install curl jq

function weather_report() {

    local response=$(curl --silent 'https://api.openweathermap.org/data/2.5/weather?id=5128581&units=imperial&appid=<YOUR_API_KEY>') 

    local status=$(echo $response | jq -r '.cod')

    # Check for the 200 response indicating a successful API query.
    case $status in

        200) printf "Location: %s %s\n" "$(echo $response | jq '.name') $(echo $response | jq '.sys.country')"  
             printf "Forecast: %s\n" "$(echo $response | jq '.weather[].description')" 
             printf "Temperature: %.1f°F\n" "$(echo $response | jq '.main.temp')" 
             printf "Temp Min: %.1f°F\n" "$(echo $response | jq '.main.temp_min')" 
             printf "Temp Max: %.1f°F\n" "$(echo $response | jq '.main.temp_max')" 
            ;;
        401) echo "401 error"
            ;;
        *) echo "error"
            ;;

    esac

}

# Output

$ weather_report

Location: "New York" "US"
Forecast: "clear sky"
Temperature: 58.0°F
Temp Min: 56.0°F
Temp Max: 60.8°F

How to Print System Information in .bashrc

You can display useful system information when you open the terminal like this:

clear

printf "\n"
printf "   %s\n" "IP ADDR: $(curl ifconfig.me)"
printf "   %s\n" "USER: $(echo $USER)"
printf "   %s\n" "DATE: $(date)"
printf "   %s\n" "UPTIME: $(uptime -p)"
printf "   %s\n" "HOSTNAME: $(hostname -f)"
printf "   %s\n" "CPU: $(awk -F: '/model name/{print $2}' | head -1)"
printf "   %s\n" "KERNEL: $(uname -rms)"
printf "   %s\n" "PACKAGES: $(dpkg --get-selections | wc -l)"
printf "   %s\n" "RESOLUTION: $(xrandr | awk '/\*/{printf $1" "}')"
printf "   %s\n" "MEMORY: $(free -m -h | awk '/Mem/{print $3"/"$2}')"
printf "\n"

Output:

Source the .bashrc file to make the changes take effect:

$ source ~/.bashrc

Here are all these custom .bashrc settings together. On a new system I paste any customization below the default code in the .bashrc file.

######################################################################
#
#
#           ██████╗  █████╗ ███████╗██╗  ██╗██████╗  ██████╗
#           ██╔══██╗██╔══██╗██╔════╝██║  ██║██╔══██╗██╔════╝
#           ██████╔╝███████║███████╗███████║██████╔╝██║     
#           ██╔══██╗██╔══██║╚════██║██╔══██║██╔══██╗██║     
#           ██████╔╝██║  ██║███████║██║  ██║██║  ██║╚██████╗
#           ╚═════╝ ╚═╝  ╚═╝╚══════╝╚═╝  ╚═╝╚═╝  ╚═╝ ╚═════╝
#
#
######################################################################

set -o vi

HISTTIMEFORMAT="%F %T "

HISTCONTROL=ignoredups

HISTSIZE=2000

HISTFILESIZE=2000

shopt -s histappend

blk='\[\033[01;30m\]'   # Black
red='\[\033[01;31m\]'   # Red
grn='\[\033[01;32m\]'   # Green
ylw='\[\033[01;33m\]'   # Yellow
blu='\[\033[01;34m\]'   # Blue
pur='\[\033[01;35m\]'   # Purple
cyn='\[\033[01;36m\]'   # Cyan
wht='\[\033[01;37m\]'   # White
clr='\[\033[00m\]'      # Reset

alias gs='git status'

alias ga='git add'

alias gaa='git add --all'

alias gc='git commit'

alias gl='git log --oneline'

alias gb='git checkout -b'

alias gd='git diff'

alias ..='cd ..;pwd'

alias ...='cd ../..;pwd'

alias ....='cd ../../..;pwd'

alias c='clear'

alias h='history'

alias tree='tree --dirsfirst -F'

alias mkdir='mkdir -p -v'

alias jan='cal -m 01'
alias feb='cal -m 02'
alias mar='cal -m 03'
alias apr='cal -m 04'
alias may='cal -m 05'
alias jun='cal -m 06'
alias jul='cal -m 07'
alias aug='cal -m 08'
alias sep='cal -m 09'
alias oct='cal -m 10'
alias nov='cal -m 11'
alias dec='cal -m 12'

function hg() {
    history | grep "$1";
}

function find_largest_files() {
    du -h -x -s -- * | sort -r -h | head -20;
}

function git_branch() {
    if [ -d .git ] ; then
        printf "%s" "($(git branch 2> /dev/null | awk '/\*/{print $2}'))";
    fi
}

# Set the prompt.
function bash_prompt(){
    PS1='${debian_chroot:+($debian_chroot)}'${blu}'$(git_branch)'${pur}' \W'${grn}' \$ '${clr}
}

bash_prompt

function git_init() {
    if [ -z "$1" ]; then
        printf "%s\n" "Please provide a directory name.";
    else
        mkdir "$1";
        builtin cd "$1";
        pwd;
        git init;
        touch readme.md .gitignore LICENSE;
        echo "# $(basename $PWD)" >> readme.md
    fi
}

function weather_report() {

    local response=$(curl --silent 'https://api.openweathermap.org/data/2.5/weather?id=5128581&units=imperial&appid=<YOUR_API_KEY>') 

    local status=$(echo $response | jq -r '.cod')

    case $status in

        200) printf "Location: %s %s\n" "$(echo $response | jq '.name') $(echo $response | jq '.sys.country')"  
             printf "Forecast: %s\n" "$(echo $response | jq '.weather[].description')" 
             printf "Temperature: %.1f°F\n" "$(echo $response | jq '.main.temp')" 
             printf "Temp Min: %.1f°F\n" "$(echo $response | jq '.main.temp_min')" 
             printf "Temp Max: %.1f°F\n" "$(echo $response | jq '.main.temp_max')" 
            ;;
        401) echo "401 error"
            ;;
        *) echo "error"
            ;;

    esac

}

clear

printf "\n"
printf "   %s\n" "IP ADDR: $(curl ifconfig.me)"
printf "   %s\n" "USER: $(echo $USER)"
printf "   %s\n" "DATE: $(date)"
printf "   %s\n" "UPTIME: $(uptime -p)"
printf "   %s\n" "HOSTNAME: $(hostname -f)"
printf "   %s\n" "CPU: $(awk -F: '/model name/{print $2}' | head -1)"
printf "   %s\n" "KERNEL: $(uname -rms)"
printf "   %s\n" "PACKAGES: $(dpkg --get-selections | wc -l)"
printf "   %s\n" "RESOLUTION: $(xrandr | awk '/\*/{printf $1" "}')"
printf "   %s\n" "MEMORY: $(free -m -h | awk '/Mem/{print $3"/"$2}')"
printf "\n"

Conclusion

In this article you learned how to configure various .bashrc options, aliases, functions, and more to greatly improve your workflow and increase your productivity.

Follow me on Github | Dev.to.

This Linux Command Handbook follows the 80/20 rule: you'll learn 80% of a topic in around 20% of the time you spend studying it.

I find that this approach gives you a well-rounded overview.

This handbook does not try to cover everything under the sun related to Linux and its commands. It focuses on the small core commands that you will use the 80% or 90% of the time, and tries to simplify the usage of the more complex ones.

All these commands work on Linux, macOS, WSL, and anywhere you have a UNIX environment.

I hope the contents of this handbook will help you achieve what you want: getting comfortable with Linux.

You can bookmark this page in your browser so you can reference this handbook in the future.

And you can download this handbook in PDF / ePUB / Mobi format for free.

Enjoy!

Table of Contents

• Introduction to Linux and shells
• The Linux man command
• The Linux ls command
• The Linux cd command
• The Linux pwd command
• The Linux mkdir command
• The Linux rmdir command
• The Linux mv command
• The Linux cp command
• The Linux open command
• The Linux touch command
• The Linux find command
• The Linux ln command
• The Linux gzip command
• The Linux gunzip command
• The Linux tar command
• The Linux alias command
• The Linux cat command
• The Linux less command
• The Linux tail command
• The Linux wc command
• The Linux grep command
• The Linux sort command
• The Linux uniq command
• The Linux diff command
• The Linux echo command
• The Linux chown command
• The Linux chmod command
• The Linux umask command
• The Linux du command
• The Linux df command
• The Linux basename command
• The Linux dirname command
• The Linux ps command
• The Linux top command
• The Linux kill command
• The Linux killall command
• The Linux jobs command
• The Linux bg command
• The Linux fg command
• The Linux type command
• The Linux which command
• The Linux nohup command
• The Linux xargs command
• The Linux vim editor command
• The Linux emacs editor command
• The Linux nano editor command
• The Linux whoami command
• The Linux who command
• The Linux su command
• The Linux sudo command
• The Linux passwd command
• The Linux ping command
• The Linux traceroute command
• The Linux clear command
• The Linux history command
• The Linux export command
• The Linux crontab command
• The Linux uname command
• The Linux env command
• The Linux printenv command
• Conclusion

Introduction to Linux and shells

What is Linux?

Linux is an operating system, like macOS or Windows.

It is also the most popular Open Source operating system, and it gives you a lot of freedom.

It powers the vast majority of the servers that compose the Internet. It's the base upon which everything is built. But not just that. Android is based on (a modified version of) Linux.

The Linux "core" (called a kernel) was born in 1991 in Finland, and it has come a really long way from its humble beginnings. It went on to be the kernel of the GNU Operating System, creating the duo GNU/Linux.

There's one thing about Linux that corporations like Microsoft, Apple, and Google will never be able to offer: the freedom to do whatever you want with your computer.

They're actually going in the opposite direction, building walled gardens, especially on the mobile side.

Linux is the ultimate freedom.

It is developed by volunteers, some paid by companies that rely on it, some independently. But there's no single commercial company that can dictate what goes into Linux, or the project's priorities.

You can also use Linux as your day to day computer. I use macOS because I really enjoy the applications and design (and I also used to be an iOS and Mac apps developer). But before using macOS I used Linux as my main computer Operating System.

No one can dictate which apps you can run, or "call home" with apps that track you, your position, and more.

Linux is also special because there's not just "one Linux", like is the case with Windows or macOS. Instead, we have distributions.

A "distro" is made by a company or organization and packages the Linux core with additional programs and tooling.

For example you have Debian, Red Hat, and Ubuntu, probably the most popular distributions.

But many, many more exist. You can create your own distribution, too. But most likely you'll use a popular one that has lots of users and a community of people around it. This lets you do what you need to do without losing too much time reinventing the wheel and figuring out answers to common problems.

Some desktop computers and laptops ship with Linux preinstalled. Or you can install it on your Windows-based computer, or on a Mac.

But you don't need to disrupt your existing computer just to get an idea of how Linux works.

I don't have a Linux computer.

If you use a Mac, you just need to know that under the hood macOS is a UNIX Operating System. It shares a lot of the same ideas and software that a GNU/Linux system uses, because GNU/Linux is a free alternative to UNIX.

UNIX is an umbrella term that groups many operating systems used in big corporations and institutions, starting from the 70's

The macOS terminal gives you access to the same exact commands I'll describe in the rest of this handbook.

Microsoft has an official Windows Subsystem for Linux which you can (and should!) install on Windows. This will give you the ability to run Linux in a very easy way on your PC.

But the vast majority of the time you will run a Linux computer in the cloud via a VPS (Virtual Private Server) like DigitalOcean.

What is a Linux shell?

A shell is a command interpreter that exposes an interface to the user to work with the underlying operating system.

It allows you to execute operations using text and commands, and it provides users advanced features like being able to create scripts.

This is important: shells let you perform things in a more optimized way than a GUI (Graphical User Interface) could ever possibly let you do. Command line tools can offer many different configuration options without being too complex to use.

There are many different kind of shells. This post focuses on Unix shells, the ones that you will find commonly on Linux and macOS computers.

Many different kind of shells were created for those systems over time, and a few of them dominate the space: Bash, Csh, Zsh, Fish and many more!

All shells originate from the Bourne Shell, called sh. "Bourne" because its creator was Steve Bourne.

Bash means Bourne-again shell. sh was proprietary and not open source, and Bash was created in 1989 to create a free alternative for the GNU project and the Free Software Foundation. Since projects had to pay to use the Bourne shell, Bash became very popular.

If you use a Mac, try opening your Mac terminal. By default it runs ZSH (or, pre-Catalina, Bash).

You can set up your system to run any kind of shell – for example I use the Fish shell.

Each single shell has its own unique features and advanced usage, but they all share a common functionality: they can let you execute programs, and they can be programmed.

In the rest of this handbook we'll see in detail the most common commands you will use.

The Linux man command

The first command I'll introduce will help you understand all the other commands.

Every time I don't know how to use a command, I type man <command> to get the manual:

This is a man (from manual) page. Man pages are an essential tool to learn as a developer. They contain so much information that sometimes it's almost too much.
The above screenshot is just 1 of 14 screens of explanation for the ls command.

Most of the time when I need to learn a command quickly I use this site called tldr pages: https://tldr.sh. It's a command you can install, which you then run like this: tldr <command>. It gives you a very quick overview of a command, with some handy examples of common usage scenarios:

This is not a substitute for man, but a handy tool to avoid losing yourself in the huge amount of information present in a man page. Then you can use the man page to explore all the different options and parameters you can use on a command.

The Linux ls command

Inside a folder you can list all the files that the folder contains using the ls command:

ls

If you add a folder name or path, it will print that folder's contents:

ls /bin

ls accepts a lot of options. One of my favorite combinations is -al. Try it:

ls -al /bin

Compared to the plain ls command, this returns much more information.

You have, from left to right:

• the file permissions (and if your system supports ACLs, you get an ACL flag as well)
• the number of links to that file
• the owner of the file
• the group of the file
• the file size in bytes
• the file's last modified datetime
• the file name

This set of data is generated by the l option. The a option instead also shows the hidden files.

Hidden files are files that start with a dot (.).

The Linux cd command

Once you have a folder, you can move into it using the cd command. cd means change directory. You invoke it specifying a folder to move into. You can specify a folder name, or an entire path.

Example:

mkdir fruits
cd fruits

Now you are in the fruits folder.

You can use the .. special path to indicate the parent folder:

cd .. #back to the home folder

The # character indicates the start of the comment, which lasts for the entire line after it's found.

You can use it to form a path:

mkdir fruits
mkdir cars
cd fruits
cd ../cars

There is another special path indicator which is ., and indicates the current folder.

You can also use absolute paths, which start from the root folder /:

cd /etc

The Linux pwd command

Whenever you feel lost in the filesystem, call the pwd command to know where you are:

pwd

It will print the current folder path.

The Linux mkdir command

You create folders using the mkdir command:

mkdir fruits

You can create multiple folders with one command:

mkdir dogs cars

You can also create multiple nested folders by adding the -p option:

mkdir -p fruits/apples

Options in UNIX commands commonly take this form. You add them right after the command name, and they change how the command behaves. You can often combine multiple options, too.

You can find which options a command supports by typing man <commandname>. Try now with man mkdir for example (press the q key to esc the man page). Man pages are the amazing built-in help for UNIX.

The Linux rmdir command

Just as you can create a folder using mkdir, you can delete a folder using rmdir:

mkdir fruits
rmdir fruits

You can also delete multiple folders at once:

mkdir fruits cars
rmdir fruits cars

The folder you delete must be empty.

To delete folders with files in them, we'll use the more generic rm command which deletes files and folders, using the -rf option:

rm -rf fruits cars

Be careful as this command does not ask for confirmation and it will immediately remove anything you ask it to remove.

There is no bin when removing files from the command line, and recovering lost files can be hard.

The Linux mv command

Once you have a file, you can move it around using the mv command. You specify the file current path, and its new path:

touch test
mv pear new_pear

The pear file is now moved to new_pear. This is how you rename files and folders.

If the last parameter is a folder, the file located at the first parameter path is going to be moved into that folder. In this case, you can specify a list of files and they will all be moved in the folder path identified by the last parameter:

touch pear
touch apple
mkdir fruits
mv pear apple fruits #pear and apple moved to the fruits folder

The Linux cp command

You can copy a file using the cp command:

touch test
cp apple another_apple

To copy folders you need to add the -r option to recursively copy the whole folder contents:

mkdir fruits
cp -r fruits cars

The Linux open command

The open command lets you open a file using this syntax:

open <filename>

You can also open a directory, which on macOS opens the Finder app with the current directory open:

open <directory name>

I use it all the time to open the current directory:

open .

The special . symbol points to the current directory, as .. points to the parent directory

The same command can also be be used to run an application:

open <application name>

The Linux touch command

You can create an empty file using the touch command:

touch apple

If the file already exists, it opens the file in write mode, and the timestamp of the file is updated.

The Linux find command

The find command can be used to find files or folders matching a particular search pattern. It searches recursively.

Let's learn how to use it by example.

Find all the files under the current tree that have the .js extension and print the relative path of each file that matches:

find . -name '*.js'

It's important to use quotes around special characters like * to avoid the shell interpreting them.

Find directories under the current tree matching the name "src":

find . -type d -name src

Use -type f to search only files, or -type l to only search symbolic links.

-name is case sensitive. use -iname to perform a case-insensitive search.

You can search under multiple root trees:

find folder1 folder2 -name filename.txt

Find directories under the current tree matching the name "node_modules" or 'public':

find . -type d -name node_modules -or -name public

You can also exclude a path using -not -path:

find . -type d -name '*.md' -not -path 'node_modules/*'

You can search files that have more than 100 characters (bytes) in them:

find . -type f -size +100c

Search files bigger than 100KB but smaller than 1MB:

find . -type f -size +100k -size -1M

Search files edited more than 3 days ago:

find . -type f -mtime +3

Search files edited in the last 24 hours:

find . -type f -mtime -1

You can delete all the files matching a search by adding the -delete option. This deletes all the files edited in the last 24 hours:

find . -type f -mtime -1 -delete

You can execute a command on each result of the search. In this example we run cat to print the file content:

find . -type f -exec cat {} \;

Notice the terminating \;. {} is filled with the file name at execution time.

The Linux ln command

The ln command is part of the Linux file system commands.

It's used to create links. What is a link? It's like a pointer to another file, or a file that points to another file. You might be familiar with Windows shortcuts. They're similar.

We have 2 types of links: hard links and soft links.

Hard links

Hard links are rarely used. They have a few limitations: you can't link to directories, and you can't link to external filesystems (disks).

A hard link is created using the following syntax:

ln <original> <link>

For example, say you have a file called recipes.txt. You can create a hard link to it using:

ln recipes.txt newrecipes.txt

The new hard link you created is indistinguishable from a regular file:

Now any time you edit any of those files, the content will be updated for both.

If you delete the original file, the link will still contain the original file content, as that's not removed until there is one hard link pointing to it.

Soft links

Soft links are different. They are more powerful as you can link to other filesystems and to directories. But keep in mind that when the original is removed, the link will be broken.

You create soft links using the -s option of ln:

ln -s <original> <link>

For example, say you have a file called recipes.txt. You can create a soft link to it using:

ln -s recipes.txt newrecipes.txt

In this case you can see there's a special l flag when you list the file using ls -al. The file name has a @ at the end, and it's also colored differently if you have colors enabled:

Now if you delete the original file, the links will be broken, and the shell will tell you "No such file or directory" if you try to access it:

The Linux gzip command

You can compress a file using the gzip compression protocol named LZ77 using the gzip command.

Here's the simplest usage:

gzip filename

This will compress the file, and append a .gz extension to it. The original file is deleted.

To prevent this, you can use the -c option and use output redirection to write the output to the filename.gz file:

gzip -c filename > filename.gz

The -c option specifies that the output will go to the standard output stream, leaving the original file intact.

Or you can use the -k option:

gzip -k filename

There are various levels of compression. The more the compression, the longer it will take to compress (and decompress). Levels range from 1 (fastest, worst compression) to 9 (slowest, better compression), and the default is 6.

You can choose a specific level with the -<NUMBER> option:

gzip -1 filename

You can compress multiple files by listing them:

gzip filename1 filename2

You can compress all the files in a directory, recursively, using the -r option:

gzip -r a_folder

The -v option prints the compression percentage information. Here's an example of it being used along with the -k (keep) option:

gzip can also be used to decompress a file, using the -d option:

gzip -d filename.gz

The Linux gunzip command

The gunzip command is basically equivalent to the gzip command, except the -d option is always enabled by default.

The command can be invoked in this way:

gunzip filename.gz

This will gunzip and will remove the .gz extension, putting the result in the filename file. If that file exists, it will overwrite that.

You can extract to a different filename using output redirection using the -c option:

gunzip -c filename.gz > anotherfilename

The Linux tar command

The tar command is used to create an archive, grouping multiple files in a single file.

Its name comes from the past and means tape archive (back when archives were stored on tapes).

This command creates an archive named archive.tar with the content of file1 and file2:

tar -cf archive.tar file1 file2

The c option stands for create. The f option is used to write to file the archive.

To extract files from an archive in the current folder, use:

tar -xf archive.tar

the x option stands for extract.

And to extract them to a specific directory, use:

tar -xf archive.tar -C directory

You can also just list the files contained in an archive:

tar is often used to create a compressed archive, gzipping the archive.

This is done using the z option:

tar -czf archive.tar.gz file1 file2

This is just like creating a tar archive, and then running gzip on it.

To unarchive a gzipped archive, you can use gunzip, or gzip -d, and then unarchive it. But tar -xf will recognize it's a gzipped archive, and do it for you:

tar -xf archive.tar.gz

The Linux alias command

It's common to always run a program with a set of options that you like using.

For example, take the ls command. By default it prints very little information:

But if you use the -al option it will print something more useful, including the file modification date, the size, the owner, and the permissions. It will also list hidden files (files starting with a .):

You can create a new command, for example I like to call it ll, that is an alias to ls -al.

You do it like this:

alias ll='ls -al'

Once you do, you can call ll just like it was a regular UNIX command:

Now calling alias without any option will list the aliases defined:

The alias will work until the terminal session is closed.

To make it permanent, you need to add it to the shell configuration. This could be ~/.bashrc or ~/.profile or ~/.bash_profile if you use the Bash shell, depending on the use case.

Be careful with quotes if you have variables in the command: if you use double quotes, the variable is resolved at definition time. If you use use single quotes, it's resolved at invocation time. Those 2 are different:

alias lsthis="ls $PWD"
alias lscurrent='ls $PWD'

\$PWD refers to the current folder the shell is in. If you now navigate away to a new folder, lscurrent lists the files in the new folder, whereas lsthis still lists the files in the folder where you were when you defined the alias.

The Linux cat command

Similar to tail in some ways, we have cat. Except cat can also add content to a file, and this makes it super powerful.

In its simplest usage, cat prints a file's content to the standard output:

cat file

You can print the content of multiple files:

cat file1 file2

and using the output redirection operator > you can concatenate the content of multiple files into a new file:

cat file1 file2 > file3

Using >> you can append the content of multiple files into a new file, creating it if it does not exist:

cat file1 file2 >> file3

When you're looking at source code files it's helpful to see the line numbers. You can have cat print them using the -n option:

cat -n file1

You can only add a number to non-blank lines using -b, or you can also remove all the multiple empty lines using -s.

cat is often used in combination with the pipe operator | to feed a file's content as input to another command: cat file1 | anothercommand.

The Linux less command

The less command is one I use a lot. It shows you the content stored inside a file, in a nice and interactive UI.

Usage: less <filename>.

Once you are inside a less session, you can quit by pressing q.

You can navigate the file contents using the up and down keys, or using the space bar and b to navigate page by page. You can also jump to the end of the file pressing G and jump back to the start by pressing g.

You can search contents inside the file by pressing / and typing a word to search. This searches forward. You can search backwards using the ? symbol and typing a word.

This command just visualises the file's content. You can directly open an editor by pressing v. It will use the system editor, which in most cases is vim.

Pressing the F key enters follow mode, or watch mode. When the file is changed by someone else, like from another program, you get to see the changes live.

This doesn't happen by default, and you only see the file version at the time you opened it. You need to press ctrl-C to quit this mode. In this case the behaviour is similar to running the tail -f <filename> command.

You can open multiple files, and navigate through them using :n (to go to the next file) and :p (to go to the previous).

The Linux tail command

The best use case of tail in my opinion is when called with the -f option. It opens the file at the end, and watches for file changes.

Any time there is new content in the file, it is printed in the window. This is great for watching log files, for example:

tail -f /var/log/system.log

To exit, press ctrl-C.

You can print the last 10 lines in a file:

tail -n 10 <filename>

You can print the whole file content starting from a specific line using + before the line number:

tail -n +10 <filename>

tail can do much more and as always my advice is to check man tail.

The Linux wc command

The wc command gives us useful information about a file or input it receives via pipes.

echo test >> test.txt
wc test.txt
1       1       5 test.txt

Example via pipes, we can count the output of running the ls -al command:

ls -al | wc
6      47     284

The first column returned is the number of lines. The second is the number of words. The third is the number of bytes.

We can tell it to just count the lines:

wc -l test.txt

or just the words:

wc -w test.txt

or just the bytes:

wc -c test.txt

Bytes in ASCII charsets equate to characters. But with non-ASCII charsets, the number of characters might differ because some characters might take multiple bytes (for example this happens in Unicode).

In this case the -m flag will help you get the correct value:

wc -m test.txt

The Linux grep command

The grep command is a very useful tool. When you master it, it will help you tremendously in your day to day coding.

If you're wondering, grep stands for global regular expression print.

You can use grep to search in files, or combine it with pipes to filter the output of another command.

For example here's how we can find the occurences of the document.getElementById line in the index.md file:

grep -n document.getElementById index.md

Using the -n option it will show the line numbers:

grep -n document.getElementById index.md

One very useful thing is to tell grep to print 2 lines before and 2 lines after the matched line to give you more context. That's done using the -C option, which accepts a number of lines:

grep -nC 2 document.getElementById index.md

Search is case sensitive by default. Use the -i flag to make it insensitive.

As mentioned, you can use grep to filter the output of another command. We can replicate the same functionality as above using:

less index.md | grep -n document.getElementById

The search string can be a regular expression, and this makes grep very powerful.

Another thing you might find very useful is to invert the result, excluding the lines that match a particular string, using the -v option:

The Linux sort command

Suppose you have a text file which contains the names of dogs:

This list is unordered.

The sort command helps you sort them by name:

Use the r option to reverse the order:

Sorting by default is case sensitive, and alphabetic. Use the --ignore-case option to sort case insensitive, and the -n option to sort using a numeric order.

If the file contains duplicate lines:

You can use the -u option to remove them:

sort does not just work on files, as many UNIX commands do – it also works with pipes. So you can use it on the output of another command. For example you can order the files returned by ls with:

ls | sort

sort is very powerful and has lots more options, which you can explore by calling man sort.

The Linux uniq command

uniq is a command that helps you sort lines of text.

You can get those lines from a file, or using pipes from the output of another command:

uniq dogs.txt

ls | uniq

You need to consider this key thing: uniq will only detect adjacent duplicate lines.

This implies that you will most likely use it along with sort:

sort dogs.txt | uniq

The sort command has its own way to remove duplicates with the -u (unique) option. But uniq has more power.

By default it removes duplicate lines:

You can tell it to only display duplicate lines, for example, with the -d option:

sort dogs.txt | uniq -d

You can use the -u option to only display non-duplicate lines:

You can count the occurrences of each line with the -c option:

Use the special combination:

sort dogs.txt | uniq -c | sort -nr

to then sort those lines by most frequent:

The Linux diff command

diff is a handy command. Suppose you have 2 files, which contain almost the same information, but you can't find the difference between the two.

diff will process the files and will tell you what's the difference.

Suppose you have 2 files: dogs.txt and moredogs.txt. The difference is that moredogs.txt contains one more dog name:

diff dogs.txt moredogs.txt will tell you the second file has one more line, line 3 with the line Vanille:

If you invert the order of the files, it will tell you that the second file is missing line 3, whose content is Vanille:

Using the -y option will compare the 2 files line by line:

The -u option however will be more familiar to you, because that's the same used by the Git version control system to display differences between versions:

Comparing directories works in the same way. You must use the -r option to compare recursively (going into subdirectories):

In case you're interested in which files differ, rather than the content, use the r and q options:

There are many more options you can explore in the man page by running man diff:

The Linux echo command

The echo command does one simple job: it prints to the output the argument passed to it.

This example:

echo "hello"

will print hello to the terminal.

We can append the output to a file:

echo "hello" >> output.txt

We can interpolate environment variables:

echo "The path variable is $PATH"

Beware that special characters need to be escaped with a backslash \. $ for example:

This is just the start. We can do some nice things when it comes to interacting with the shell features.

We can echo the files in the current folder:

echo *

We can echo the files in the current folder that start with the letter o:

echo o*

Any valid Bash (or any shell you are using) command and feature can be used here.

You can print your home folder path:

echo ~

You can also execute commands, and print the result to the standard output (or to file, as you saw):

echo $(ls -al)

Note that whitespace is not preserved by default. You need to wrap the command in double quotes to do so:

You can generate a list of strings, for example ranges:

echo {1..5}

The Linux chown command

Every file/directory in an Operating System like Linux or macOS (and every UNIX system in general) has an owner.

The owner of a file can do everything with it. It can decide the fate of that file.

The owner (and the root user) can change the owner to another user, too, using the chown command:

chown <owner> <file>

Like this:

chown flavio test.txt

For example if you have a file that's owned by root, you can't write to it as another user:

You can use chown to transfer the ownership to you:

It's rather common to need to change the ownership of a directory, and recursively all the files contained, plus all the subdirectories and the files contained in them, too.

You can do so using the -R flag:

chown -R <owner> <file>

Files/directories don't just have an owner, they also have a group. Through this command you can change that simultaneously while you change the owner:

chown <owner>:<group> <file>

Example:

chown flavio:users test.txt

You can also just change the group of a file using the chgrp command:

chgrp <group> <filename>

The Linux chmod command

Every file in the Linux / macOS Operating Systems (and UNIX systems in general) has 3 permissions: read, write, and execute.

Go into a folder, and run the ls -al command.

The weird strings you see on each file line, like drwxr-xr-x, define the permissions of the file or folder.

Let's dissect it.

The first letter indicates the type of file:

• - means it's a normal file
• d means it's a directory
• l means it's a link

Then you have 3 sets of values:

• The first set represents the permissions of the owner of the file
• The second set represents the permissions of the members of the group the file is associated to
• The third set represents the permissions of the everyone else

Those sets are composed by 3 values. rwx means that specific persona has read, write and execution access. Anything that is removed is swapped with a -, which lets you form various combinations of values and relative permissions: rw-, r--, r-x, and so on.

You can change the permissions given to a file using the chmod command.

chmod can be used in 2 ways. The first is using symbolic arguments, the second is using numeric arguments. Let's start with symbols first, which is more intuitive.

You type chmod followed by a space, and a letter:

• a stands for all
• u stands for user
• g stands for group
• o stands for others

Then you type either + or - to add a permission, or to remove it. Then you enter one or more permission symbols (r, w, x).

All followed by the file or folder name.

Here are some examples:

chmod a+r filename #everyone can now read
chmod a+rw filename #everyone can now read and write
chmod o-rwx filename #others (not the owner, not in the same group of the file) cannot read, write or execute the file

You can apply the same permissions to multiple personas by adding multiple letters before the +/-:

chmod og-r filename #other and group can't read any more

In case you are editing a folder, you can apply the permissions to every file contained in that folder using the -r (recursive) flag.

Numeric arguments are faster but I find them hard to remember when you are not using them day to day. You use a digit that represents the permissions of the persona. This number value can be a maximum of 7, and it's calculated in this way:

• 1 if has execution permission
• 2 if has write permission
• 4 if has read permission

This gives us 4 combinations:

• 0 no permissions
• 1 can execute
• 2 can write
• 3 can write, execute
• 4 can read
• 5 can read, execute
• 6 can read, write
• 7 can read, write and execute

We use them in pairs of 3, to set the permissions of all the 3 groups altogether:

chmod 777 filename
chmod 755 filename
chmod 644 filename

The Linux umask command

When you create a file, you don't have to decide permissions up front. Permissions have defaults.

Those defaults can be controlled and modified using the umask command.

Typing umask with no arguments will show you the current umask, in this case 0022:

What does 0022 mean? That's an octal value that represents the permissions.

Another common value is 0002.

Use umask -S to see a human-readable notation:

In this case, the user (u), owner of the file, has read, write and execution permissions on files.

Other users belonging to the same group (g) have read and execution permission, same as all the other users (o).

In the numeric notation, we typically change the last 3 digits.

Here's a list that gives a meaning to the number:

• 0 read, write, execute
• 1 read and write
• 2 read and execute
• 3 read only
• 4 write and execute
• 5 write only
• 6 execute only
• 7 no permissions

Note that this numeric notation differs from the one we use in chmod.

We can set a new value for the mask setting the value in numeric format:

umask 002

or you can change a specific role's permission:

umask g+r

The Linux du command

The du command will calculate the size of a directory as a whole:

du

The 32 number here is a value expressed in bytes.

Running du * will calculate the size of each file individually:

You can set du to display values in MegaBytes using du -m, and GigaBytes using du -g.

The -h option will show a human-readable notation for sizes, adapting to the size:

Adding the -a option will print the size of each file in the directories, too:

A handy thing is to sort the directories by size:

du -h <directory> | sort -nr

and then piping to head to only get the first 10 results:

The Linux df command

The df command is used to get disk usage information.

Its basic form will print information about the volumes mounted:

Using the -h option (df -h) will show those values in a human-readable format:

You can also specify a file or directory name to get information about the specific volume it lives on:

The Linux basename command

Suppose you have a path to a file, for example /Users/flavio/test.txt.

Running

basename /Users/flavio/test.txt

will return the test.txt string:

If you run basename on a path string that points to a directory, you will get the last segment of the path. In this example, /Users/flavio is a directory:

The Linux dirname command

Suppose you have a path to a file, for example /Users/flavio/test.txt.

Running

dirname /Users/flavio/test.txt

will return the /Users/flavio string:

The Linux ps command

Your computer is running tons of different processes at all times.

You can inspect them all using the ps command:

This is the list of user-initiated processes currently running in the current session.

Here I have a few fish shell instances, mostly opened by VS Code inside the editor, and an instance of Hugo running the development preview of a site.

Those are just the commands assigned to the current user. To list all processes we need to pass some options to ps.

The most common one I use is ps ax:

The a option is used to also list other users' processes, not just your own. x shows processes not linked to any terminal (not initiated by users through a terminal).

As you can see, the longer commands are cut. Use the command ps axww to continue the command listing on a new line instead of cutting it:

We need to specify w 2 times to apply this setting (it's not a typo).

You can search for a specific process combining grep with a pipe, like this:

ps axww | grep "Visual Studio Code"

The columns returned by ps represent some key information.

The first information is PID, the process ID. This is key when you want to reference this process in another command, for example to kill it.

Then we have TT that tells us the terminal id used.

Then STAT tells us the state of the process:

I a process that is idle (sleeping for longer than about 20 seconds) R a runnable process S a process that is sleeping for less than about 20 seconds T a stopped process U a process in uninterruptible wait Z a dead process (a zombie)

If you have more than one letter, the second represents further information, which can be very technical.

It's common to have + which indicates that the process is in the foreground in its terminal. s means the process is a session leader.

TIME tells us how long the process has been running.

The Linux top command

The top command is used to display dynamic real-time information about running processes in the system.

It's really handy to understand what is going on.

Its usage is simple – you just type top, and the terminal will be fully immersed in this new view:

The process is long-running. To quit, you can type the q letter or ctrl-C.

There's a lot of information being given to us: the number of processes, how many are running or sleeping, the system load, the CPU usage, and a lot more.

Below, the list of processes taking the most memory and CPU is constantly updated.

By default, as you can see from the %CPU column highlighted, they are sorted by the CPU used.

You can add a flag to sort processes by memory utilized:

top -o mem

The Linux kill command

Linux processes can receive signals and react to them.

That's one way we can interact with running programs.

The kill program can send a variety of signals to a program.

It's not just used to terminate a program, like the name would suggest, but that's its main job.

We use it in this way:

kill <PID>

By default, this sends the TERM signal to the process id specified.

We can use flags to send other signals, including:

kill -HUP <PID>
kill -INT <PID>
kill -KILL <PID>
kill -TERM <PID>
kill -CONT <PID>
kill -STOP <PID>

HUP means hang up. It's sent automatically when a terminal window that started a process is closed before terminating the process.

INT means interrupt, and it sends the same signal used when we press ctrl-C in the terminal, which usually terminates the process.

KILL is not sent to the process, but to the operating system kernel, which immediately stops and terminates the process.

TERM means terminate. The process will receive it and terminate itself. It's the default signal sent by kill.

CONT means continue. It can be used to resume a stopped process.

STOP is not sent to the process, but to the operating system kernel, which immediately stops (but does not terminate) the process.

You might see numbers used instead, like kill -1 <PID>. In this case,

1 corresponds to HUP. 2 corresponds to INT. 9 corresponds to KILL. 15 corresponds to TERM. 18 corresponds to CONT. 15 corresponds to STOP.

The Linux killall command

Similar to the kill command, killall will send the signal to multiple processes at once instead of sending a signal to a specific process id.

This is the syntax:

killall <name>

where name is the name of a program. For example you can have multiple instances of the top program running, and killall top will terminate them all.

You can specify the signal, like with kill (and check the kill tutorial to read more about the specific kinds of signals we can send), for example:

killall -HUP top

The Linux jobs command

When we run a command in Linux / macOS, we can set it to run in the background using the & symbol after the command.

For example we can run top in the background:

top &

This is very handy for long-running programs.

We can get back to that program using the fg command. This works fine if we just have one job in the background, otherwise we need to use the job number: fg 1, fg 2 and so on.

To get the job number, we use the jobs command.

Say we run top & and then top -o mem &, so we have 2 top instances running. jobs will tell us this:

Now we can switch back to one of those using fg <jobid>. To stop the program again we can hit cmd-Z.

Running jobs -l will also print the process id of each job.

The Linux bg command

When a command is running you can suspend it using ctrl-Z.

The command will immediately stop, and you get back to the shell terminal.

You can resume the execution of the command in the background, so it will keep running but it will not prevent you from doing other work in the terminal.

In this example I have 2 commands stopped:

I can run bg 1 to resume in the background the execution of the job #1.

I could have also said bg without any option, as the default is to pick the job #1 in the list.

The Linux fg command

When a command is running in the background, because you started it with & at the end (example: top & or because you put it in the background with the bg command), you can put it to the foreground using fg.

Running

fg

will resume in the foreground the last job that was suspended.

You can also specify which job you want to resume to the foreground passing the job number, which you can get using the jobs command.

Running fg 2 will resume job #2:

The Linux type command

A command can be one of those 4 types:

• an executable
• a shell built-in program
• a shell function
• an alias

The type command can help figure this out, in case we want to know or we're just curious. It will tell you how the command will be interpreted.

The output will depend on the shell used. This is Bash:

This is Zsh:

This is Fish:

One of the most interesting things here is that for aliases it will tell you what it is aliasing to. You can see the ll alias, in the case of Bash and Zsh, but Fish provides it by default, so it will tell you it's a built-in shell function.

The Linux which command

Suppose you have a command you can execute, because it's in the shell path, but you want to know where it is located.

You can do so using which. The command will return the path to the command specified:

which will only work for executables stored on disk, not aliases or built-in shell functions.

The Linux nohup command

Sometimes you have to run a long-lived process on a remote machine, and then you need to disconnect.

Or you simply want to prevent the command from being halted if there's any network issue between you and the server.

The way to make a command run even after you log out or close the session to a server is to use the nohup command.

Use nohup <command> to let the process continue working even after you log out.

The Linux xargs command

The xargs command is used in a UNIX shell to convert input from standard input into arguments to a command.

In other words, through the use of xargs the output of a command is used as the input of another command.

Here's the syntax you will use:

command1 | xargs command2

We use a pipe (|) to pass the output to xargs. That will take care of running the command2 command, using the output of command1 as its argument(s).

Let's do a simple example. You want to remove some specific files from a directory. Those files are listed inside a text file.

We have 3 files: file1, file2, file3.

In todelete.txt we have a list of files we want to delete, in this example file1 and file3:

We will channel the output of cat todelete.txt to the rm command, through xargs.

In this way:

cat todelete.txt | xargs rm

That's the result, the files we listed are now deleted:

The way it works is that xargs will run rm 2 times, one for each line returned by cat.

This is the simplest usage of xargs. There are several options we can use.

One of the most useful, in my opinion (especially when starting to learn xargs), is -p. Using this option will make xargs print a confirmation prompt with the action it's going to take:

The -n option lets you tell xargs to perform one iteration at a time, so you can individually confirm them with -p. Here we tell xargs to perform one iteration at a time with -n1:

The -I option is another widely used one. It allows you to get the output into a placeholder, and then you can do various things.

One of them is to run multiple commands:

command1 | xargs -I % /bin/bash -c 'command2 %; command3 %'

You can swap the % symbol I used above with anything else – it's a variable.

The Linux vim editor command

vim is a very popular file editor, especially among programmers. It's actively developed and frequently updated, and there's a big community around it. There's even a Vim conference!

vi in modern systems is just an alias for vim, which means vi improved.

You start it by running vi on the command line.

You can specify a filename at invocation time to edit that specific file:

vi test.txt

You have to know that Vim has 2 main modes:

• command (or normal) mode
• insert mode

When you start the editor, you are in command mode. You can't enter text like you expect from a GUI-based editor. You have to enter insert mode.

You can do this by pressing the i key. Once you do so, the -- INSERT -- word appears at the bottom of the editor:

Now you can start typing and filling the screen with the file contents:

You can move around the file with the arrow keys, or using the h - j - k - l keys. h-l for left-right, j-k for down-up.

Once you are done editing you can press the esc key to exit insert mode and go back to command mode.

At this point you can navigate the file, but you can't add content to it (and be careful which keys you press, as they might be commands).

One thing you might want to do now is save the file. You can do so by pressing : (colon), then w.

You can save and quit by pressing : then w and q: :wq

You can quit without saving by pressing : then q and !: :q!

You can undo and edit by going to command mode and pressing u. You can redo (cancel an undo) by pressing ctrl-r.

Those are the basics of working with Vim. From here starts a rabbit hole we can't go into in this little introduction.

I will only mention those commands that will get you started editing with Vim:

• pressing the x key deletes the character currently highlighted
• pressing A goes to the end of the currently selected line
• press 0 to go to the start of the line
• go to the first character of a word and press d followed by w to delete that word. If you follow it with e instead of w, the white space before the next word is preserved
• use a number between d and w to delete more than 1 word, for example use d3w to delete 3 words forward
• press d followed by d to delete a whole entire line. Press d followed by $ to delete the entire line from where the cursor is, until the end

To find out more about Vim I can recommend the Vim FAQ. You can also run the vimtutor command, which should already be installed in your system and will greatly help you start your vim exploration.

The Linux emacs editor command

emacs is an awesome editor and it's historically regarded as the editor for UNIX systems. Famously, vi vs emacs flame wars and heated discussions have caused many unproductive hours for developers around the world.

emacs is very powerful. Some people use it all day long as a kind of operating system (https://news.ycombinator.com/item?id=19127258). We'll just talk about the basics here.

You can open a new emacs session simply by invoking emacs:

macOS users, stop a second now. If you are on Linux there are no problems, but macOS does not ship applications using GPLv3, and every built-in UNIX command that has been updated to GPLv3 has not been updated.

While there is a little problem with the commands I listed up to now, in this case using an emacs version from 2007 is not exactly the same as using a version with 12 years of improvements and change.

This is not a problem with Vim, which is up to date. To fix this, run brew install emacs and running emacs will use the new version from Homebrew (make sure you have Homebrew installed).

You can also edit an existing file by calling emacs <filename>:

You can now start editing. Once you are done, press ctrl-x followed by ctrl-w. You confirm the folder:

and Emacs tells you the file exists, asking you if it should overwrite it:

Answer y, and you get a confirmation of success:

You can exit Emacs by pressing ctrl-x followed by ctrl-c. Or ctrl-x followed by c (keep ctrl pressed).

There is a lot to know about Emacs, certainly more than I am able to write in this little introduction. I encourage you to open Emacs and press ctrl-h r to open the built-in manual and ctrl-h t to open the official tutorial.

The Linux nano editor command

nano is a beginner friendly editor.

Run it using nano <filename>.

You can directly type characters into the file without worrying about modes.

You can quit without editing using ctrl-X. If you edited the file buffer, the editor will ask you for confirmation and you can save the edits, or discard them.

The help at the bottom shows you the keyboard commands that let you work with the file:

pico is more or less the same, although nano is the GNU version of pico which at some point in history was not open source. The nano clone was made to satisfy the GNU operating system license requirements.

The Linux whoami command

Type whoami to print the user name currently logged in to the terminal session:

Note: this is different from the who am i command, which prints more information

The Linux who command

The who command displays the users logged in to the system.

Unless you're using a server multiple people have access to, chances are you will be the only user logged in, multiple times:

Why multiple times? Because each shell opened will count as an access.

You can see the name of the terminal used, and the time/day the session was started.

The -aH flags will tell who to display more information, including the idle time and the process ID of the terminal:

The special who am i command will list the current terminal session details:

The Linux su command

While you're logged in to the terminal shell with one user, you might need to switch to another user.

For example you're logged in as root to perform some maintenance, but then you want to switch to a user account.

You can do so with the su command:

su <username>

For example: su flavio.

If you're logged in as a user, running su without anything else will prompt you to enter the root user password, as that's the default behavior.

su will start a new shell as another user.

When you're done, typing exit in the shell will close that shell, and will return you back to the current user's shell.

The Linux sudo command

sudo is commonly used to run a command as root.

You must be enabled to use sudo, and once you are, you can run commands as root by entering your user's password (not the root user password).

The permissions are highly configurable, which is great especially in a multi-user server environment. Some users can be granted access to running specific commands through sudo.

For example you can edit a system configuration file:

sudo nano /etc/hosts

which would otherwise fail to save since you don't have the permissions for it.

You can run sudo -i to start a shell as root:

You can use sudo to run commands as any user. root is the default, but use the -u option to specify another user:

sudo -u flavio ls /Users/flavio

The Linux passwd command

Users in Linux have a password assigned. You can change the password using the passwd command.

There are two situations here.

The first is when you want to change your password. In this case you type:

passwd

and an interactive prompt will ask you for the old password, then it will ask you for the new one:

When you're root (or have superuser privileges) you can set the username for which you want to change the password:

passwd <username> <new password>

In this case you don't need to enter the old one.

The Linux ping command

The ping command pings a specific network host, on the local network or on the Internet.

You use it with the syntax ping <host> where <host> could be a domain name, or an IP address.

Here's an example pinging google.com:

The command sends a request to the server, and the server returns a response.

ping keeps sending the request every second, by default. It will keep running until you stop it with ctrl-C, unless you pass the number of times you want to try with the -c option: ping -c 2 google.com.

Once ping is stopped, it will print some statistics about the results: the percentage of packages lost, and statistics about the network performance.

As you can see the screen prints the host IP address, and the time that it took to get the response back.

Not all servers support pinging, in case the request times out:

Sometimes this is done on purpose, to "hide" the server, or just to reduce the load. The ping packets can also be filtered by firewalls.

ping works using the ICMP protocol (Internet Control Message Protocol), a network layer protocol just like TCP or UDP.

The request sends a packet to the server with the ECHO_REQUEST message, and the server returns a ECHO_REPLY message. I won't go into details, but this is the basic concept.

Pinging a host is useful to know if the host is reachable (supposing it implements ping), and how distant it is in terms of how long it takes to get back to you.

Usually the nearer the server is geographically, the less time it will take to return back to you. Simple physical laws cause a longer distance to introduce more delay in the cables.

The Linux traceroute command

When you try to reach a host on the Internet, you go through your home router. Then you reach your ISP network, which in turn goes through its own upstream network router, and so on, until you finally reach the host.

Have you ever wanted to know what steps your packets go through to do that?

The traceroute command is made for this.

You invoke

traceroute <host>

and it will (slowly) gather all the information while the packet travels.

In this example I tried reaching for my blog with traceroute flaviocopes.com:

Not every router travelled returns us information. In this case, traceroute prints * * *. Otherwise, we can see the hostname, the IP address, and some performance indicator.

For every router we can see 3 samples, which means traceroute tries by default 3 times to get you a good indication of the time needed to reach it.

This is why it takes this long to execute traceroute compared to simply doing a ping to that host.

You can customize this number with the -q option:

traceroute -q 1 flaviocopes.com

The Linux clear command

Type clear to clear all the previous commands that were run in the current terminal.

The screen will clear and you will just see the prompt at the top:

Note: this command has a handy shortcut: ctrl-L

Once you do that, you will lose access to scrolling to see the output of the previous commands entered.

So you might want to use clear -x instead, which still clears the screen, but lets you go back to see the previous work by scrolling up.

The Linux history command

Every time you run a command, it's memorized in the history.

You can display all the history using:

history

This shows the history with numbers:

You can use the syntax !<command number> to repeat a command stored in the history. In the above example typing !121 will repeat the ls -al | wc -l command.

Typically the last 500 commands are stored in the history.

You can combine this with grep to find a command you ran:

history | grep docker

To clear the history, run history -c.

The Linux export command

The export command is used to export variables to child processes.

What does this mean?

Suppose you have a variable TEST defined in this way:

TEST="test"

You can print its value using echo $TEST:

But if you try defining a Bash script in a file script.sh with the above command:

Then when you set chmod u+x script.sh and you execute this script with ./script.sh, the echo $TEST line will print nothing!

This is because in Bash the TEST variable was defined local to the shell. When executing a shell script or another command, a subshell is launched to execute it, which does not contain the current shell local variables.

To make the variable available there we need to define TEST not in this way:

TEST="test"

but in this way:

export TEST="test"

Try that, and running ./script.sh now should print "test":

Sometimes you need to append something to a variable. It's often done with the PATH variable. You use this syntax:

export PATH=$PATH:/new/path

It's common to use export when you create new variables in this way. But you can also use it when you create variables in the .bash_profile or .bashrc configuration files with Bash, or in .zshenv with Zsh.

To remove a variable, use the -n option:

export -n TEST

Calling export without any option will list all the exported variables.

The Linux crontab command

Cron jobs are jobs that are scheduled to run at specific intervals. You might have a command perform something every hour, or every day, or every 2 weeks. Or on weekends.

They are very powerful, especially when used on servers to perform maintenance and automations.

The crontab command is the entry point to work with cron jobs.

The first thing you can do is to explore which cron jobs are defined by you:

crontab -l

You might have none, like me:

Run

crontab -e

to edit the cron jobs, and add new ones.

By default this opens with the default editor, which is usually vim. I like nano more. You can use this line to use a different editor:

EDITOR=nano crontab -e

Now you can add one line for each cron job.

The syntax to define cron jobs is kind of scary. This is why I usually use a website to help me generate it without errors: https://crontab-generator.org/

You pick a time interval for the cron job, and you type the command to execute.

I chose to run a script located in /Users/flavio/test.sh every 12 hours. This is the crontab line I need to run:

* */12 * * * /Users/flavio/test.sh >/dev/null 2>&1

I run crontab -e:

EDITOR=nano crontab -e

and I add that line, then I press ctrl-X and press y to save.

If all goes well, the cron job is set up:

Once this is done, you can see the list of active cron jobs by running:

crontab -l

You can remove a cron job running crontab -e again, removing the line and exiting the editor:

The Linux uname command

Calling uname without any options will return the Operating System codename:

The m option shows the hardware name (x86_64 in this example) and the p option prints the processor architecture name (i386 in this example):

The s option prints the Operating System name. r prints the release, and v prints the version:

The n option prints the node network name:

The a option prints all the information available:

On macOS you can also use the sw_vers command to print more information about the macOS Operating System. Note that this differs from the Darwin (the Kernel) version, which above is 19.6.0.

Darwin is the name of the kernel of macOS. The kernel is the "core" of the Operating System, while the Operating System as a whole is called macOS. In Linux, Linux is the kernel, and GNU/Linux would be the Operating System name (although we all refer to it as "Linux").

The Linux env command

The env command can be used to pass environment variables without setting them on the outer environment (the current shell).

Suppose you want to run a Node.js app and set the USER variable to it.

You can run

env USER=flavio node app.js

and the USER environment variable will be accessible from the Node.js app via the Node process.env interface.

You can also run the command clearing all the environment variables already set, using the -i option:

env -i node app.js

In this case you will get an error saying env: node: No such file or directory because the node command is not reachable, as the PATH variable used by the shell to look up commands in the common paths is unset.

So you need to pass the full path to the node program:

env -i /usr/local/bin/node app.js

Try with a simple app.js file with this content:

console.log(process.env.NAME)
console.log(process.env.PATH)

You will see the output as

undefined
undefined

You can pass an env variable:

env -i NAME=flavio node app.js

and the output will be

flavio
undefined

Removing the -i option will make PATH available again inside the program:

The env command can also be used to print out all the environment variables. If run with no options:

env

it will return a list of the environment variables set, for example:

HOME=/Users/flavio
LOGNAME=flavio
PATH=/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/Library/Apple/usr/bin
PWD=/Users/flavio
SHELL=/usr/local/bin/fish

You can also make a variable inaccessible inside the program you run, using the -u option. For example this code removes the HOME variable from the command environment:

env -u HOME node app.js

The Linux printenv command

Here's a quick guide to the printenv command, used to print the values of environment variables

In any shell there are a good number of environment variables, set either by the system, or by your own shell scripts and configuration.

You can print them all to the terminal using the printenv command. The output will be something like this:

HOME=/Users/flavio
LOGNAME=flavio
PATH=/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/Library/Apple/usr/bin
PWD=/Users/flavio
SHELL=/usr/local/bin/fish

with a few more lines, usually.

You can append a variable name as a parameter, to only show that variable value:

printenv PATH

Conclusion

Thanks a lot for reading this handbook.

I hope it will inspire you to learn more about Linux and its capabilities. It's evergreen knowledge that will not be out of date any time soon.

Remember that you can download this handbook in PDF / ePUB / Mobi format if you want!

I publish programming tutorials every day on my website flaviocopes.com if you want to check out more great content like this.

You can reach me on Twitter @flaviocopes.

grep stands for Globally Search For Regular Expression and Print out. It is a command line tool used in UNIX and Linux systems to search a specified pattern in a file or group of files.

grep comes with a lot of options which allow us to perform various search-related actions on files. In this article, we'll look at how to use grep with the options available as well as basic regular expressions to search files.

How to use grep

Without passing any option, grep can be used to search for a pattern in a file or group of files. The syntax is:

grep '<text-to-be-searched>' <file/files>

Note that single or double quotes are required around the text if it is more than one word.

You can also use the wildcard (*) to select all files in a directory.

The result of this is the occurences of the pattern (by the line it is found) in the file(s). If there is no match, no output will be printed to the terminal.

For example, say we have the following files (called grep.txt):

Hello, how are you
I am grep
Nice to meet you

The following grep command will search for all occurences of the word 'you':

grep you grep.txt

The result for this is:

Hello, how are you
Nice to meet you

you is expected to have a different color than the other text to easily identify what was searched for.

But grep comes with more options which help us achieve more during a search operation. Let's look at nine of them while applying them to the example above.

Options used with grep

1. -n (--line-number) - list line numbers

This prints out the matches for the text along with the line numbers. If you look at the result we have above, you'll notice there are no line numbers, just the matches.

grep you grep.txt -n

Result:

1: Hello, how are you
3: Nice to meet you

2. -c (--count) - prints the number of lines of matches

grep you grep.txt -c

Result:

2

Note that if there was another 'you' on line one, option -c would still print 2. This is because it is concerned with the number of lines where the matches appear, not the number of matches.

3. -v (--invert-match) - prints the lines that do not match the specified pattern

grep you grep.txt -v -n

Result:

2. I am grep

Notice that we also used option -n? Yes, you can apply multiple options in one command.

4. -i (--ignore-case) - used for case insensitivity

# command 1
grep You grep.txt
# command 2
grep YoU grep.txt -i

Results:

# result 1
# no result
# result 2
Hello, how are you
Nice to meet you

5. -l (--files-with-matches) - print file names that match a pattern

# command 1
grep you grep.txt -l
# command 2
grep You grep.txt -i -l

Results:

# result 1
grep.txt
# result 2
# all files in the current directory that matches
# the text 'You' case insensitively

6. -w (--word-regexp) - print matches of the whole word

By default, grep matches strings which contain the specified pattern. This means that grep yo grep.txt will print the same results as grep yo grep.txt because 'yo' can be found in you. Similarly, 'ou'.

With the option -w, grep ensures that the matches are exactly the same pattern as specified. Example:

grep yo grep.txt -w

Result:

No result!

7. -o (--only-matching) - print only the matched pattern

By default, grep prints the line where the matched pattern is found. With option -o, only the matched pattern is printed line by line. Example:

grep yo grep.txt -o

Result:

yo

8. -A (--after-context) and -B (--before-context) - print the lines after and before (respectively) the matched pattern

grep grep grep.txt -A 1 -B 1

Result:

Hello, how are you
I am grep
Nice to meet you

This matched pattern is on line 2. -A 1 means one line after the matched line and -B 1 means one line before the matched line.

There's also a -C (--context) option which is equal to -A + -B. The value passed to -C would be used for -A and -B.

9. -R (--dereference-recursive) - recursive search

By default, grep cannot search directories. If you try doing so, you'll get an error ("Is a directory"). With option -R, searching files within directories and subdirectories becomes possible. Example:

grep you .

Result:

# 'you' matches in a folders
# and files starting from the
# current directory

Regular expressions for patterns

grep also allows basic regular expressions for specifying patterns. Two of them are:

1. ^pattern - start of a line

This pattern means that the grep will match the strings whose lines begin with the string specified after ^. Example:

grep ^I grep.txt -n

Result:

2: I

2. pattern$ - end of a line

In contrast with ^, $ specifies patterns that will be matched if the line ends with the string before $. Example:

grep you$ grep.txt

Result:

1: Hello, how are you
3: Nice to meet you

Wrap up

grep is a powerful tool for searching files in the terminal. Understanding how to use it gives you the ability to easily find files via the terminal.

There are more options attached to this tool. You can find with man grep.

A symlink (also called a symbolic link) is a type of file in Linux that points to another file or a folder on your computer. Symlinks are similar to shortcuts in Windows.

Some people call symlinks "soft links" – a type of link in Linux/UNIX systems – as opposed to "hard links."

Difference Between a Soft Link and a Hard Link

Soft links are similar to shortcuts, and can point to another file or directory in any file system.

Hard links are also shortcuts for files and folders, but a hard link cannot be created for a folder or file in a different file system.

Let's look at the steps involved in creating and removing a symlink. We'll also see what broken links are, and how to delete them.

How to Create a Symlink

The syntax for creating a symlink is:

ln -s <path to the file/folder to be linked> <the path of the link to be created>

ln is the link command. The -s flag specifies that the link should be soft. -s can also be entered as -symbolic.

By default, ln command creates hard links. The next argument is path to the file (or folder) that you want to link. (That is, the file or folder you want to create a shortcut for.)

And the last argument is the path to link itself (the shortcut).

How to Create a Symlink for a File – Example Command

ln -s /home/james/transactions.txt trans.txt

After running this command, you will be able to access the /home/james/transactions.txt with trans.txt. Any modification to trans.txt will also be reflected in the original file.

Note that this command above would create the link file trans.txt in your current directory. You can as well create a linked file in a folder link this:

ln -s /home/james/transactions.txt my-stuffs/trans.txt

There must be a directory already called "my-stuffs" in your current directory – if not the command will throw an error.

How to Create a Symlink for a Folder – Example Command

Similar to above, we'd use:

ln -s /home/james james

This would create a symlinked folder called 'james' which would contain the contents of /home/james. Any changes to this linked folder will also affect the original folder.

How to remove a symlink

Before you'd want to remove a symlink, you may want to confirm that a file or folder is a symlink, so that you do not tamper with your files.

One way to do this is:

ls -l <path-to-assumed-symlink>

Running this command on your terminal will display the properties of the file. In the result, if the first character is a small letter L ('l'), it means the file/folder is a symlink.

You'd also see an arrow (->) at the end indicating the file/folder the simlink is pointing to.

There are two methods to remove a symlink:

How to Use Unlink to Remove a Symlink

The syntax is:

unlink <path-to-symlink>

This deletes the symlink if the process is successful.

Even if the symlink is in the form of a folder, do not append '/', because Linux will assume it's a directory and unlink can't delete directories.

How to use rm to Remove a Symlink

As we've seen, a symlink is just another file or folder pointing to an original file or folder. To remove that relationship, you can remove the linked file.

Hence, the syntax is:

rm <path-to-symlink>

For example:

rm trans.txt
rm james

Note that trying to do rm james/ would result an error, because Linux will assume 'james/' is a directory, which would require other options like r and f. But that's not what we want. A symlink may be a folder, but we are only concerned with the name.

The main benefit of rm over unlink is that you can remove multiple symlinks at once, like you can with files.

How to Find and Delete Broken Links

Broken links occur when the file or folder that a symlink points to changes path or is deleted.

For example, if 'transactions.txt' moves from /home/james to /home/james/personal, the 'trans.txt' link becomes broken. Every attempt to access to the file will result in a 'No such file or directory' error. This is because the link has no contents of its own.

When you discover broken links, you can easily delete the file. An easy way to find broken symlinks is:

find /home/james -xtype l

This will list all broken symlinks in the james directory – from files to directories to sub-directories.

Passing the -delete option will delete them like so:

find /home/james -xtype l -delete

Wrapping up

Symbolic link are an interesting feature of Linux and UNIX systems.

You can create easily accessible symlinks to refer to a file or folder that would otherwise not be convenient to access. With some practice, you will understand how these work on an intuitive level, and they will make you much more efficient at managing file systems.

BSD is configured for internet hosting, web hosting, and hosting many servers on one system. It is the first OS to have added an internet protocol. BSD OSes have a very strongly enforced time-sharing system, which makes them most useful where resources are shared between processes.

As a comparison, the Linux OS is known to be preferred for single-task processes such as supercomputers and desktops. The effective BSD multi-tasking forced-interrupt part of timesharing gets in the way of dedicated single processes.

BSD includes a ‘Jails’ system which is somewhat analogous to Linux Containers —except with additional security and flexibility in implementation.

More Information:

• FreeBSD (Wikipedia.org)
• OpenBSD (Wikipedia.org)
• NetBSD (Wikipedia.org)
• Comparison of BSD operating systems (Wikipedia.org)

Testing SSH

If you haven’t already, test that you are able to SSH into the server. SFTP uses the Secure Shell (SSH) protocol, so if you are unable to SSH you probably won’t be able to SFTP either.

ssh your_username@hostname_or_ip_address

Start SFTP Session

This uses the same syntax as SSH and opens a session in which you can transfer files.

sftp your_username@hostname_or_ip_address

To list helpful commands:

help

Transfer files and folders

To download a file:

get <filename>

To download a folder and its contents, use the “-r” flag (also works for uploading):

get -r <foldername>

To upload a file:

put <filename>

Change folders

To change the local folder:

lcd <path/to/folder>

To change the remote folder:

cd <path/to/folder>

Today, let’s take a look at “Program Design in the Unix Environment” published in 1983 by Pike and Kernighan.

The paper opens by listing why Unix has been successful, and then comments on the Unix philosophy and its benefits. It does so by looking at examples where programs diverged from the Unix philosophy and discussing the resulting trade offs

The reasons for Unix’s success:

1. Portability: the kernel & applications were written in C, so they could be moved from system to system without being re-written in the assembly language particular to that system.
2. The same OS ran on different hardware, so the users were already familiar and didn’t have to relearn when new hardware was released.
3. The vendors could ship the same software with each machine despite changes in hardware.
4. The system was not too big and was easy to modify since everything was written in C.
5. It provided a new philosophy based on the use of general purpose tools. They did one thing well and could be combined to do a particular task, instead of creating giant monolithic tools that served only one purpose.

The paper argues that the use and design of tools is closely related, and how they fit together is the main subject of this essay.

The paper then dives into cat (the Unix command line utility for concatenating and printing files). It copies its input to its output. The input is usually a sequence of one or more files or the standard input. The output is a file or the standard output.

The main purpose of cat was to act as a utility to concatenate files. It can be combined with the pipe (|) operator to further enhance and extend its utility through output redirection.

Other systems, on the other hand, try to dump a bunch of related functionality into a single command which is against the Unix philosophy. It also creates a lock-in of functionality that might be useful to other programs.

Advantages of the Unix approach:

1. The shell and the programs it can invoke provide uniform access to system facilities. Eg: the filename arguments are expanded by the shell in a similar fashion for each command. Because of pipes, we don’t need every command to deal with pre- and post- processing of input.
2. Growth is easy when functions are well-separated.

Example: the `(backtic) operator was added to convert the output of one program into the input of another without requiring changes in any other program as it is interpreted by the shell. All programs the shell invokes acquire this feature automatically. If each program that required this feature interpreted it, it’d be very hard to enforce uniformity and carry out further experimentation, as each new idea would affect all the programs that would want to use it.

However, in future versions of cat, many new options were introduced (such as printing line numbers and non-printable characters).

The authors argue that instead of adding those options to cat itself, either existing programs should’ve been used or new programs should’ve been created. For example, line number functionality could’ve been provided by using pr. However, there was no program which allowed printing of non-printable characters which warranted the creation of a new one.

Such a modification confuses what cat’s job is  concatenating files  with
what it happens to do in a common special case  showing a file on the terminal. A UNIX program should do one thing well, and leave unrelated tasks to other programs. cat’s job is to collect the data in files. Programs that collect data shouldn’t change the data; cat therefore shouldn’t transform its input.

Whenever we split something into multiple programs, we sacrifice some efficiency. But since cat is usually used without any options, it makes sense to have the most common cases be the most efficient.

Separate programs are not always better than wider options; which is better depends on the problem. Whenever one needs a way to perform a new function, one faces the choice of whether to add a new option or write a new program (assuming that none of the programmable tools will do the job conveniently). The
guiding principle for making the choice should be that each program does one thing. Options are appropriately added to a program that already has the right functionality. If there is no such program, then a new program is called for. In that case, the usual criteria for program design should be used: the program should be as general as possible, its default behavior should match the most common usage, and it should cooperate with other programs.

Let’s consider another issue: dealing with fast terminal lines. How do we deal with output from cat scrolling off the top of the screen?

There are two approaches:

1. Tell each command about terminal properties so it does the right thing
2. Write a command that handles only terminals without modifying other programs

Let’s consider examples of both approaches: lsc and ls which prints out the list of files in a directory.

lsc varies its output depending on the input. It displays the list in a columnar fashion across the screen so that the o/p fits if it’s outputting to the terminal. ls displays everything in a single column.

By retaining single column output to files or pipes, lsc ensures compatibility with programs like grep or wc that expect things to be printed one per line. This ad-hoc adjustment of the output format depending on the destination is not only distasteful, it is unique  no standard UNIX command has this property.

The authors argue that the columnation facility is useful in general and shouldn’t be locked away in just lsc , making it inaccessible to other programs. They advocate for a different program whose primary job is columnation.

Similar reasoning suggests a solution for the general problem of data flowing off screens (columnated or not): a separate program to take any input and print it a screen at a time. Such programs are by now widely available, under names like pg and more. This solution affects no other programs, but can be used with all of them. As usual, once the basic feature is right, the program can be enhanced with options…

Based on the previous example, the authors also talk about different cases where some functionality is locked away in a specific program (like input history in the terminal) which would be better off as a central service. All interactive programs could benefit from it.

They conclude with how augmenting existing commands with features/options is not desirable in Unix, it goes against its basic philosophy: make a program do one thing well. Several such programs can be composed to accomplish a more complex task.

The key to problem solving on the UNIX system is to identify the right primitive operations and to put them at the right place. UNIX programs tend to solve general problems rather than special cases. In a very loose sense, the programs are orthogonal, spanning the space of jobs to be done (although with a fair
amount of overlap for reasons of history, convenience or efficiency). Functions are placed where they will do the most good: there shouldn’t be a pager in every program that produces output any more than there should be filename pattern matching in every program that uses filenames.

One thing that UNIX does not need is more features. It is successful in part because it has a small number of good ideas that work well together. Merely adding features does not make it easier for users to do things  it just makes the manual thicker. The right solution in the right place is always more effective
than haphazard hacking.

A brief guide to getting started on UNIX/Mac OS terminal

When I was first introduced to the command line I really had to adjust to navigating my computer in a black box with just text. So I avoided the command line as much as possible. I was accustomed to the visual cues and feedback that a computer usually provides. In many ways it felt like I was re-learning how to use a computer via the command line.

Yet, since first learning how to navigate my computer using UNIX commands I’ve learned that the command line doesn’t have to be a scary thing just because there’s no visual feedback when typing a password in on the command line. As security, nothing shows up as you type in your password to indicate that any characters have been entered.

What is the command line?

The command line is a software that executes commands or instructions for a computer to manipulate or interact with its file system.

What is UNIX?

Why Use the Command Line?

• Faster to modify, navigate between files
• Able to install software as a superuser
• Can see hidden dotfiles
  dotfiles are UNIX configuration files, they tend to be files that are proceeded with a . and are hidden to normal users.
  You can learn more about getting started with dotfiles in this article).

In order to get started on the command line you should navigate to your applications and open the Terminal application.

Above is the Terminal Icon on Mac.

Create a Basic Website Folder on the Command Line

Folder structure of sample project

A folder with the above structure can be create on the command line by typing the commands inside of an empty directory:

We start inside of an empty directory!

• Make a directory (also known as a folder) called personal-website
  mkdir personal-website

We’ve created a folder named personal-website

• Navigate to inside of the directory called personal-website
  cd personal-website
• create a directory, inside of the personal-website folder called assets
  mkdir assets

We’ve created a folder inside of personal-website to contain all of our assets

• Navigate inside of the assets folder which is inside of the personal-website folder
  cd assets
• create a directory, inside of the assets folder named images
  mdkir images
• create a directory, inside of the assets folder named js
  mkdir js
• create a directory, inside of the assets folder named css
  mkdir css

We’ve created folders inside of personal-website/assets to store our project’s assets

Woops! We forgot to create an index.html file :(

We are in the assets folder and want an index.html file in our main personal-website folder. Typing cd .. will move us out of the assets folder and into the directory above which is personal-website. Now that we are in the personal-website folder if we type touch index.html a blank index.html file will be created.

Some frequently used terminal commands are:

commands to navigate/manipulate the filesystem

ls
list the contents of a directory

pwd
print working directory for the terminal to display the directory you are currently working on

touch
create or open a file without making any changes
very handy when wanting to create empty files without leaving the command line

sudo
this allows you to run commands as a super user

mv
move a file or directory
this can be used to move or rename a file by updating the file path

cd
change the current directory you are working on so that you can access files on a different part of the system
cd moves you to the root directory (top level folder on computer — usually the current User)
cd . current directory
cd .. navigates to directory two levels up

mkdir
make a new directory (or a folder)

Commands to Install Software

You can install some software from the command line using the following commands:

• in Python pip install <package name>.
  Pip is a software package manager for Python.
• in JavaScript npm install <package name>
  NPM is a package manager for JavaScript pages.

Commands to Run Software

In order to run a script on the command line you need to provide a command prompt and file name. Some examples are:

• in Java javac filename.java and then java filename compiles java projects and then runs them.
• in Python python filename runs python scripts.

If you find you are repeating a lot of commands you can scroll through your recent commands using the up/down arrows and edit them and re-run by navigating to them and then pressing enter.

Additional Resources to Get Started with Command Line Prompts

• MIT Terminus (interactive game to learn command line)
• Codecademy Learn the Command Line
• Learn Python the Hard Way’s Command Line Crash Course

Decorating the Command Line

You can completely customize the colors and outputs on the command line to better suit your visual and aesthetic needs.

Here’s how I’ve made my command line prettier :

How to install Tomorrow Night
https://github.com/chriskempson/tomorrow-theme/blob/master/OS%20X%20Terminal/Tomorrow%20Night.terminal

Customize the terminal
_I love the terminal. Besides the fact it makes you look awesome while using it, it can also do about a gazillion…_mindthecode.com

If you enjoyed reading this article consider tapping the clap button ?. Wanna see more of my work? Check out my GitHub to view my code and learn more about my development experience at http://aboutmonica.com.