Shells were originally created with the invention of Unix all the way back to the early 1970’s. Over the years, these shells have continually evolved with the technology and the needs of the users.

The first and most obvious feature is the command prompt. Although it’s a very simple interface for entering commands, it can be customized with a lot of advanced features to make working from it very productive.

An important feature is environment variables. These variables are used for customization, configuration and processing information. For example the PATH environment variable contains a list of directory paths the shell uses to find the commands from. Also the prompt, language, default editor and default pager are come of the settings found in the environment variables.

Each shell also have several builtin commands that add a lot of functionality and further configurable options. This includes multitasking and job management as well as IO redirection and piping.

Although the command prompt looks very simple most shells include a lot of advanced editing features. This includes cut, copy, paste, inserting, deleting and auto completion. Auto completion makes the TAB key absolutely magical.

Every command is saved in a history file that is searchable and commands can be recalled in many ways. The history can be used interactively and through builtin commands its behaviour tailored.

Commands can get quite complicated and hard to remember. To make this situation easier, commands can be saved into a text file known as a shell script. A shell script can be run as a command itself and is an incredibly powerful way to automate tasks.

The entire Unix operating system is based on the idea of it being a toolbox. Where a program does one thing, does is well and works with other programs. This toolbox approach doesn’t make any assumption on how the technology will be used but rather offers a great amount of flexibility with how it can be used. The simplicity of the text interface makes it very light weight and is one of the best compromises between the computer and the user. This interface allows programs be simple and lean and allows the user to truly harness the capabilities of the computer.

Now that we have all the pieces, with in the next articles, we can start looking at putting all of this to work.

For the uninitiated, Vi is an un-intuitive nightmare that makes no sense at all. When you open a new or empty file with the default Vi on FreeBSD you get an almost blank console. If you just start typing all hell breaks loose. Despite all this, it has been and still is a default editor on just about every Unix based system out there.

To get an understanding how Vi works you first have to understand it has several modes. The initial mode is the COMMAND mode. This is where the keys you type execute various commands instead of inserting characters into the document, for example; x – deletes a character, j – move down a line, :w – write to the file and :q – quit the editor. The ‘i’ key will switch to the INSERT mode where now you can type characters into the document as you expected in the first place. The ESC key will switch you back to COMMAND mode.

The power Vi is the ability for commands to be combined together to make editing easy with very few key strokes. It’s light weight with one purpose in mind, editing a file. Only in its relative recent history, can you open and edit more than file at a time.

The Emacs editor, also cheekily known as the Escape-Alt-Meta-Control Sequence editor, shouldn’t be considered just a text editor. Although this is the main purpose of the program, it’s more along the lines of a lisp interpreter with a text editor as a front end. Most people think of this the other way around, a text editor extended by lisp, and this is wrong in my opinion. Just about every key you type executes a lisp command that can be reassigned. This means emacs can be used for so much more than just editing files. Actually it can do just about anything, email, games, terminal, debugging and so much more.

Emacs is the clear winner, right? Well it’s not so simple, with features comes software bloat and when you start using all these features Emacs becomes quite a heavy weight. It’s takes some experience be able to use its features and keep the startup times down and running fairly lean. Not to mention how much there is to learn. After 20 years of using Emacs, I’m still learning about all the features it has to offer.

So who’s winning… neither editor! It’s like comparing apples with oranges. Although they are both technically text editors that’s where the similarities end. They both function very differently with different project goals in mind. If you had to decide which one to learn it all depends on your needs and both are worth learning.

Stay away from the flame wars. If someone tells you that one editor is flat out better than the other, they are wrong. If someone tells you never to use one of the editors, they are wrong. I wouldn’t trust the opinion of anyone that trashes on one or the other. Listen to the pro and cons for each editor. As mentioned before, ultimately which is the best choice for you is up to you and your needs.

For myself, I use Emacs for everything. All the articles and pages on this website are written in Emacs using org-mode. I also use it to check emails, programming, watch my system logs, task lists and so on. It can be a complete desktop in itself. I do use Vi usually for editing system configuration files and simple edits.

There are also several projects that are attempting to solve this debate by creating their own console text editors. So Vi and Emacs aren’t your only options. In the end, live in peace and you do you… or is that just to cheesy 😉

To understand the terminal interface, we’re going to take a quick look at how data is represented by computers internally. Everyone knows computers work in 1’s and 0’s also know as binary¹. Lets briefly review how this is done.

When we count we do so in a numbering system called base 10. Base 10 means we have 10 digits in our numbering system 0-9. When we get to the number 9 another digit is added to get the next number 10. It works the same way with binary also known as base 2. There are 2 digits 0-1 and after 1 we add digits just like base 10.

The basic size of a number used by computers is 8 digits or bits also know as a byte. A byte has 256 values 0 to 255 (or 127 to -128 if we use signed values). When bigger numbers are required the number of digits/bits used is doubled, increasing to 16 bits, 32 bits, 64 bits and so on. Once we have 16 bits or higher there’s a quirk between different computer architectures known as endianness. There are two common endian systems, big and little. A big endian system orders the bytes the way you’d expect starting with the most significant digit going down to the least significant digit. A little endian system reverses this order.

On an individual computer endianness is completely transparent and doesn’t affect anything. But in a world connected by the internet, sharing binary data between different systems makes this a very important issue (32768 on one system could equal 1 on another). This might not seem to have much to do with terminal interfaces, but it gives insight into why text formatted data is still, to this day, a hugely popular format preferred over raw binary data.

Terminals are text encoded interfaces. They can use encodings like ASCII, code pages or Unicode. Typically a new terminal window starts with an 80×25 grid of characters and a cursor. Each character can have it’s own colours, be bold or underlined. On the surface, terminals seem extremely simple and in many ways they are but can have an endless amount of configurable options. If you look at the manual for xterm, man xterm, it goes on and on with no end in sight. Terminal software can have a lot of features that can vary for each different software suite.

I’m not going to go into all the features in this article, but an important one that all terminals support are escape codes. We’ve seen how we can display information on the terminal by writing to standard out. For a program to use the features of the terminal, like colouring text or move the cursor around, the ASCII escape character (33) is written to standard out with a number of other codes describing the desired effect.

Here’s a simple example using escape codes with the bash shell and in an xterm compatible terminal.

echo -e "Using escape codes: \033[01;32mI'm in color\033[00m"

There are a lot of common escape codes supported by the different terminal software, but each terminal also have their own unique codes as well. In later articles, when we start looking at shell scripting, I’ll show how you can use programs like tput to take advantage of the terminal features with having to worry about the differences in escape codes.

Now that we have trudged through all this different components and systems we can move on to the heart of it all the “Command Line Shells”…