Getting older, not necessarily wiser!
What is the Linux Command Line? And why is it so scary for many people? While most Linux enthusiasts embrace the command line, most other computer users don’t want anything to do with it. It is not, after all, a nice friendly Graphical user Interface (GUI). This series of posts is not for either of them, the GUI folk, nor is it for the Linux enthusiasts. However if you are interested in expanding your knowledge and capabilities when it comes to using your computer, then welcome!
In this post I will be discussing a simplified overview of the command line from the perspective of someone wanting to become more familiar with using the command line, with minimal technical jargon (can’t escape it all together).
This is not the only place to learn the command line. There are plenty of resources available, at much grander levels of detail and complexity, if you find my views somewhat simplistic.
I am also working on a video series for this particular topic, while getting ready to move. So I expect this to be a slow roller.
Note: while helpful for general understanding, this part is not essential. So feel free to jump ahead.
Unless you are using system without a GUI, most likely you will be doing your command line stuff in a terminal. I have noted some confusion about the difference between a terminal and a shell. So this is a short high level overview.
At the heart of the system is the Linux Kernel. It is the interface between programs and the hardware. To talk to the hardware there are various kernel driver modules. To talk to the rest of the computer, there are system libraries (chunks of reusable programing).
The system libraries are the boundary between user space and kernel space (generally not accessible by normal users, reserved and protected).
The Shell is the interface between User Space and Kernel Space. In the Shell we can run commands send input and receive output form various programs. A Shell interface can be text or graphical. There are also different types of shells available for various reasons.
If you are running a GUI and need to interact with the shell via text, you need an additional program called a terminal emulator (or Terminal for short). The Terminal emulates a text based Shell interface when running a graphical mode.
Note: while helpful for general understanding, this part is also not essential. So feel free to jump ahead.
Over the years there have been many different text based Shells created.
Bourne Shell (sh): Written by Stephen Bourne in 1976, and superseded the PWB shell (developed in 1973) with the release of UNIX 7.
Bourne Again Shell (bash): Written by Brian Fox in 1989 as part of the GNU free software project. It introduced several improvements on sh, was in the public domain, and was the standard in most early Linux distributions.
C Shell (csh): Created by Bill Joy in the late 1970’s, with the purpose of being similar in appearance to C coding, and was more interactive for the user. On some systems the csh is replaced by tcsh (improved version), while on others they are separate.
Korn Shell (ksh): Written in early 1980s by David Korn. It is based on sh with some of the features found in csh.
Almquist shell (ash): Written by Kenneth Almquist, in the late 1980’s. It replaced sh in the BSD version of UNIX.
Debian Almquist shell (dash): Written in 1997 by Herbert Xu, this was a port of the ash shell to Debian Linux. While bash is still the default login shell, dash shell replaced the sh shell in both Ubuntu and Debian in 2006.
There are other shells and variations of shells out there. But the above should cover the ones most users are ever likely to run across.
Note that in this series of posts we will be using bash. Different shells can have different context and variations. So things that work in bash may not work in other shells.
Note: while helpful for general understanding, this part is also not essential. So feel free to jump ahead. Because there is even more variation between terminal emulators, I will only be covering some of the most popular ones.
Xterm: This is the default standard terminal emulator for the X Windows system. Written in 1984, by Mark Vandevoorde, it actually predates X Windows. Most terminal emulators under X started here, and there are a large number of variants (like UXTerm).
GNOME Terminal: This is the default terminal emulator shipped with the GNOME desktop. As such its look and feel come from the GTK tool kit. Generally this terminal emulator is easier to customize than Xterm. It looks better than Xterm, but from what I have experienced it is a bit slower.
Konsole: This is the default terminal emulator for the KDE Plasma desktop. Based on the QT tool kit, the appearance of Konsole is easier to customize than Xterm. Like a lot of KDE application, Konsole also supports tabs, so it is possible to have several terminals open on one window. In my experience Konsole is also somewhat slower than xterm.
Terminator: Written by Phil Norman in 2004, this terminal emulator is Java based, so it is available cross platform. Like some of the other terminal emulators, Terminator is somewhat on the heavy side. While easier to configure, it also runs somewhat slower than xterm.
Other desktops also have their own version of a terminal emulator. For example Qtermail comes with eh LxQT desktop.
This is going to be dependent on your needs. But to be perfectly blunt the performance of the shell and terminal are probably not going to be an issue, or even noticeable, for most average users. It will all come down to how much you like the look and feel of any particular terminal emulator.
My advice, initially stick with what comes standard in your distribution and desktop. Once you have gained a little experience, you can branch out and try other options. You can easily have several different shells and terminals installed on your Linux system.
There is nothing that we will be doing in this series of posts that should not work across a variety of shells and terminals.
For this series of posts, this is my setup.
This has been a brief introduction to both Shells and terminal Emulators. It is high level, and not meant to be in depth on any particular combination.
At some point I will be following up with a few posts about using the command line. Like this post it will be fairly high level and aimed at the new/novice user.
The Linux Command Line Part 1; An Introduction