Hello World

It’s tradition to begin a new “language” by creating a simple script to output the words “Hello World!”. That’s easy enough, just open your favorite text editor and enter the following:

#!/bin/bash
echo Hello World!

With only two lines, it couldn’t be a whole lot simpler, but that first line, #!/bin/bash, may not be immediately obvious. The first two characters (often called a hashbang) are a special signal. It tells Linux that this script should be run through the /bin/bash shell, as opposed to the C shell or Korn shell or anything else you might have installed. Without it, there’s no easy way for Linux to tell exactly what type of shell script this is. A Python script, for example, would likely start with something like #!/usr/bin/python.

After that is just the echo statement, which prints the words after it to the terminal (technically, to standard output).

Running Your Script

As is often the case with Linux, there are multiple ways to do this job. The most basic way would be to call bash manually and feed it the script file, as in

#Filename can be anything, .sh is a common practice for shell scripts.
bash myscript.sh

Clever readers may be thinking “But wait, didn’t we put that hashbang thing in so it would know to use bash? Why did I have to run bash manually?” and the answer is “You didn’t“. At least, you wouldn’t have if we had taken a moment to make the script executable on its own.

In the previous example, we launched bash and sent it the script. Now we’ll save ourselves some future time by making the script executable so we dont need to run bash manually. That’s as easy as a single command.

chmod +x myscript.sh

And now it can be run with the filename directly.

Variables and Arguments

Variables in bash can be a little more confusing than some other scripting languages, partly because they sometimes need to be prefaced with a $ character and sometimes not – depending on what you’re doing. Take the following example.

PATH=$PATH:/home/josh/scripts

We refer to the same variable, PATH, two times. Once there’s no $, but the other time there is. There are a few ways that you can remember when a $ is appropriate, but this author uses a “talking” metaphor. If I’m talking TO the variable (such as assigning it a new value) I call it by the short name, in this case PATH. If I’m talking ABOUT a variable (such as getting its current value) it gets a more formal title ($PATH). The precise reasoning and inner workings of this design are beyond the scope of this guide, so just try to remember that you need to include a $ if you’re trying to fetch the information in a variable.

Now we’re going to use a variable in our script. Change the second line to look like the following:

#!/bin/bash
echo Hello $1!

And re-run your script, but this time include your name after the script name.

Bash auto-assigns certain variables for you, including a few such as $1, $2 etc which hold each of the arguments passed to the script. Variables can be reassigned and renamed any way you wish, so you could rewrite the previous script as

#!/bin/bash
 
firstname=$1
lastname=$2
 
echo Hello $firstname $lastname!

As you can see, there are no $ signs when assigning the value to the variable, but you do need them when pulling the info out.

Conditionals and Loops

No script could get very far without the ability to analyse or loop through data. The most common method of determining a course of action is to use the if statement. It works much like you’d expect – IF something THEN do stuff ELSE do something different. This example compares the string of characters that we stored in the variable firstname and compares it to some hardcoded text. If they match, it prints special output. Otherwise, it continues as normal.

#!/bin/bash
 
firstname=$1
lastname=$2
 
if [ "$firstname" == "Josh" ]
then
  echo "What a great name"
else
  echo Hello $firstname $lastname!
fi

Finally, the next core component is bash’s ability to loop over data. The normal looping mechanisms for bash are FOR, WHILE, and UNTIL. We’ll start with while, as it’s the simplest.

#!/bin/bash 
         counter=0
         #While the counter is less than 10, keep looping
         while [  $counter -lt 50 ]; do
             echo $counter
             let counter=counter+1 
         done

That example creates a counter variable, begins a while loop, and continues looping (and adding one to the counter) until it reaches the limit, in this case 50. Anything after the done statement will execute once the loop is complete.

UNTIL operates similarly, but as the reverse of WHILE. A while loop will continue as long as its expression is true (counter less than 50). The until loop takes the opposite approach, and would be written as

until [  $counter -gt 50 ]; do

In this example, “while less than 50″ and “until greater than 50″ will have nearly identical results (the difference being that one will include the number 50 itself, and the other will not. Try it out for yourself to see which one, and why.)

Conclusion

As stated above, it would take a lot more than a single Getting Started article to fully demonstrate the power of bash scripting. The pieces shown here can be seen as the core components of how bash operates, and should suffice to show you the basic principles behind shell scripting in Linux. If you really want to get into the guts and start making some great scripts, check out GNU’s official bash reference guide here. Happy scripting!

1. Making a Temporary Filesystem (Ramdisk)

There are several reasons to make a temporary RAM-based filesystem such as fast read/write times or to guarantee that the files will not persist after reboot. Making such a “fake” filesystem is easy, and just requires one command.

mount -t tmpfs tmpfs /mytemppartition -o size=1024m

Where /mytemppartion is the location you wish to mount (it must already exist) and 1024m is the desired size of the ramdisk.

2. Quickly Scheduling Commands

Linux pros almost certainly know the at command, it lets you set a specific time for a job to be run. You simply say what to do and when to do it, and at takes care of the rest. Its usage can be confusing for some, so here’s one common way of scheduling a task with at.

at 12:30 #Enter key
somecommandtorun
anothercommand
#ctrl-D

If you want to verify that it worked, you can easily list the sceduled jobs with

at -l

3. Re-run Previous Commands

Perhaps you ran a long complicated command, but forgot to preface it with sudo, or maybe you didn’t add some necessary options to the end. Instead of retyping the whole thing or going back through your shell history, you can use “double bangs” to represent your last command.

mkdir /etc/myDir
#Permission denied
sudo !!
#Success!

If you’re the type who tracks your command history numbers, you can use the same approach to recall any previous command by referencing its number:

4. Find the PID of a Process

If you need to kill a particular process but don’t have its PID, there’s a simple shortcut to find it – the pgrep command. It doesn’t do anything that can’t be done with a combination of ps and grep, but every little bit helps.

5. Find the Fastest Apt Mirror

Most Debian-derived distributions (but not Ubuntu) have access to a great tool that seems to go largely unnoticed. It’s called apt-spy, and its purpose is to scan the list of known Debian mirrors to find the fastest one for you.

apt-spy update
#This example will scan stable branch of 20 american mirrors for 30 seconds each
apt-spy -d stable -a America -e 20 -t 30

6. Show Listening Ports and their Processes

If you need to see what’s listening for connections on your system, and the processes handling those connections, the old trusty netstat tool is up to the job. Try

netstat -tlnp

to see just such a list.

7. SSH Without Passwords

Many people, such as this author, use SSH on a nearly constant basis. It’s a great tool, there’s no denying that, but having to constantly retype your passwords can get annoying. Instead, you can simply copy your (public) SSH information to the remote machine, allowing it to authenticate you without requiring your password, and all you need is a single command.

ssh-copy-id username@remote-machine

Conclusion

Obviously we’ve only begun to scratch the surface when it comes to useful CLI tools, but the ones listed here are a few of those that we at MTE consider indispensable. If you’ve got any favorite utilities that we forgot to mention, let us know in the comments below.

Overview

Let’s say you’re at the command line, and you’re running a long process like a kernel recompile. On some machines, that can take up to an hour. An average user might sit and wait. A clever user might background the job, or use the function keys to open a new TTY login. A screen user, however, has already thought ahead. Had screen been launched first (or automatically – more on that later) that user would just hit the proper key combo to create a new shell. And another, and another, if desired. Each one operates independently of the others and all output will remain on the appropriate screen session.

Some of you who like to use the ALT-CTRL-(F1 through F4) method may wonder how screen is any better. Several reasons actually, some of which would be:

1. Not limited to number of function keys
2. Ability to name each screen
3. Ability to detach/reattach screen sessions
4. “Status Bar” support
5. Multi-user shared screens
6. Split screens

A LOTS more.

Getting Started

As screen is included in nearly every major Linux distro, this guide will not cover installation. The simplest way to launch screen is to just open a terminal and type

screen

You might get a welcome screen, but otherwise you may not notice anything different. It just looks like a normal terminal right?

What you’re actually seeing is the default screen session, and you can think of it as a layer over your shell. Should you exit or detach the session, you’d be returned to your normal screen-less shell.

Adding and Navigating Screens

For starters, you’ll need to know one major key combo. This is the “magic” key combo that lets you access all the individual commands. What is this magical combination? Ctrl-A. For example, Ctrl-A followed by c will create a new screen. Ctrl-A and n will move to the next screen in line (if one exists). The following includes many of the most common action keys (all keys are case-sensitive):

• c – Create a new screen
• n – Move to next screen
• p – Move to previous screen
• S – Split screen into stacked regions
• | – Split to side-by-side regions (might not work on all systems)
• d – Detach screen
• A – Set screen title

Attaching/Detaching Screens

While there are many great uses for screen, this function could be called screen’s bread and butter. The ability to detach a screen, leaving it running, and pick it back up later is invaluable.

Let’s say you’re running the Minecraft server from last week, and it’s running on an old PC under your bed. Normally if you wanted to, say, enter commands at the server console, you’d have to pull out the machine, dig out a keyboard and monitor, run your commands, and push it all back. Had the server software been started in a screen session, you can just SSH into the server, re-attach the screen, and do what you need. When done, detach the screen, and the server will keep running even after you close the SSH session. Days/weeks/months later, you can log back into the server and reattach that screen to enter new commands.

.screenrc

Finally, we could not cover screen without at least a brief mention of the ~/.screenrc file. There are many many uses for this file, but as this is an introductory guide, we will not cover all possible options. Instead, we’ll just point out the well-loved hardstatus setting.

This option gives you a fantastically useful info bar that will persist across all screen sessions. Typically, it’s placed at the bottom and holds info such as time, hostname, and title/number of the current screen.

You can find example hardstatus codes all over the net with your preferred search engine, but here are a few to get you started.

#1

hardstatus alwayslastline
hardstatus string '%{= kG}[ %{G}%H %{g}][%= %{= kw}%?%-Lw%?%{r}(%{W}%n*%f%t%?(%u)%?%{r})%{w}%?%+Lw%?%?%= %{g}][%{B} %d/%m %{W}%c %{g}]'

#2

hardstatus alwayslastline
hardstatus string "%{+b Rk}(%{-b g}$LOGNAME@%H%{+b R}) (%{-b g}%C %a%{+b R}) %{-b g} %n %t %h"

#3

hardstatus alwayslastline
hardstatus string '%{= M} %H%{= G} %l %= %{= w}%-w%{+b r}%n*%t%{-b r}%{w}%+w %= %{c}%d %D %{B}%c '

The Basic Desktop

When it launches, the Gnome Shell desktop is pretty sparse. In fact, all you’ve really got is a thin panel on the top.

It’s more-or-less like the default top panel you’d find on your average Gnome install. The user text in the upper right corner acts much like the equivalent Gnome applet in Ubuntu.

Things get interesting once you click the Activities button, or move your mouse all the way to the top left. This activates the nuts-and-bolts of Gnome Shell, the Activities screen.

Windows and Applications

If you have no applications open, the Activities screen doesn’t show very much to start.

But once you open a few things, possibly through the sidebar dock, you’ll see one of the features of Gnome Shell: decluttering your workspace.

However many windows you have open on that workspace will be sorted for easy viewing and access. As you may see in the screenshot above, Gnome Shell adds a close button to the window under the cursor, so excess applications can be removed without leaving the Activities screen.

So far that’s just the Windows section. If you look near the top of the Activities screen, you’ll also see Applications. Clicking this brings up the full application screen.

On the right you can choose specific categories of applications, much like the traditional Gnome menu.

The Dock

The sidebar dock provided here is a pretty simple one, and is actually similar in many ways to the one found in Unity. It is a launcher of course and also tracks the open applications, so that if you click the icon when the application is open, it will move you to the appropriate workspace. Items can be added and removed by right clicking to icon to add it as a “Favorite”.

Workspaces

This is where Gnome Shell has always stood above most other desktop environments: its ability to manage multiple workspaces. So far there seem to be three approaches to workspace management. Early builds placed workspaces in a grid layout showing you all at once:

Fedora, and the live CD used for this article, place their workspace icons at the bottom of the Activities screen, and you click the “+” or “-” icons on the right to add and remove new workspaces.

But there are some screenshots circulating of a third method which, to some, may be the best of both worlds.

Enhanced Search

In the upper right corner you’ve got your search box. This can not only pick up applications and system settings, but you can use it to directly search sites like Google and Wikipedia.

Conclusion

As for this author’s opinion – I love it. While I can’t claim to take sides on the Compiz vs Clutter debate, it’s my opinion that Gnome Shell is the best designed desktop environment I’ve yet seen. This is coming from someone who’s very very picky about their interface. In Gnome Shell, all actions are fluid. Windows fade or slide into place. Transitions from one screen to the next are smooth and uninterrupted. To many it may resemble the feel of a modern smart phone more than a desktop. It’s a pity Ubuntu isn’t going to fully back it, they’ve got the best track record of giving a desktop the polish it really needs. I, for one, am very excited about the future of Gnome Shell and can’t wait to see where it goes.

Image credit: Jimmac

Installing Bashish

Not all the links on the Bashish Download Page seem to be working, however the source tarball is working fine. Once extracted, it can be installed from the command line with

./configure && make && sudo make install

If you need details on the above steps, see How to Install Software from a Tarball in Linux.

You’ll need to restart your shell for Bashish to take effect.

Choosing Themes

Bashish comes with several themes in the base package, and you can list them with the command

bashish list

And once you’ve seen a theme you’d like to try, just enter

bashish (theme name)

There is an alternate method, which will allow you to browse the themes instead of specifying one-at-a-time, but in the tests performed for this article, the theme manager failed to apply changes to theme selection, so the above method is recommended. Should you wish to try the theme manager, it can be run with the command bashishtheme and requires the dialog program in order to run properly.

Disabling Bashish

There are some cases in which Bashish might cause problems with software run through it, so the developers have included a fairly simple way to temporarily suspend Bashish for the duration of a process. To run a command without Bashish, run it as

BASHISH_DISABLED=1 your_command

Recommended Themes

Of the themes included with Bashish, there are a few that stand out as especially cool (at least in this author’s opinion). The following themes are the ones we’d most recommend, either for usefulness or simply because of the cool factor.

The Box theme applies a border around each section of your output, marking a clear distinction between events.

The Bashish2 theme is an elegant 2-liner with some minimal information.

The default theme BlueSteel, and with good reason. It looks lovely and contains several bits of useful info.

Elite and Elite2 are favorites as well, because they pack a lot of info into a small space, and include bash history number in the top line.

The LCARS theme is clearly more about style than substance, as it’s intended to resemble the LCARS computer interface seen on several Star Trek series. It doesn’t give much in the ways of useful info, and it takes up a lot of space, but it deserves a mention.

Finally, for those who want a clear visual split between commands, but not a bunch of text in the way, we’ve got the simplistic Uberprompt.

Conclusion

If you want a fancy shell without trying to decode a line like PS1=”\[\033[35m\]\t\[\033[m\]-\[\033[36m\]\u\[\033[m\]@\[\033[32m\]\h:\[\033[33;1m\]\w\[\033[m\]\$ “ to do it, Bashish is a great way to go. There are enough built-in themes to satisfy just about anyone, and for the most part, they look great. This author will probably be using BlueSteel for quite a while.

Installation

It’s important to note right away that Gnome Shell is still in fairly early development. There is no stable release or package, we’ll be downloading and installing from source code using an auto build script. While I had no trouble at all with the installation, things could change at any moment so there’s certainly no guarantees that it will build, let alone run. That said, Gnome Shell has so far given me no trouble at all.

First, we’ll need jhbuild, a tool that’ll help with the installation. It’s probably in your distro’s repositories. Debian/Ubuntu users an fetch it with:

sudo apt-get install jhbuild

Next we download and run the installation script:

wget http://git.gnome.org/cgit/gnome-shell/plain/tools/build/gnome-shell-build-setup.sh
bash gnome-shell-build-setup.sh
jhbuild build

This will take a little while. It ran for about 10 minutes on my Core 2 Duo test machine. Fortunately, there were no errors during any part of it during my installation.

Running

BEFORE RUNNING GNOME SHELL, make sure to disable Compiz if you’ve got it running. Ubuntu users can do this by opening your normal Gnome panel to System -> Preferences -> Appearance and turning off desktop effects. Once you’re sure any desktop effects have been disabled, save any work you’re not willing to risk, and enter the following in your terminal:

~/gnome-shell/source/gnome-shell/src/gnome-shell --replace

If you find yourself liking Gnome Shell and running it often, I’d suggest making an alias in your .bashrc file for the command above.

Launching Applications

The main difference in working with the Gnome Shell desktop is that your panel on the top is not your normal panel, Once you click Activities, you’ll see a completely different interface from what you’re used to.

You can also open the Activities screen by hitting the Super (aka Windows) key on your keyboard. On the left, you’ve got the equivalent of the old menu system. The top of that panel is the Find box, which operates like many of the desktop finder tools out there. You can type in the name of a program (like “firefox”) to run it, or you can specify a word in the program’s description, like below.

The other method of launching programs is to click the Browse button under Applications, if you prefer using menus.

Multiple Desktops

No Linux desktop environment would be complete if it wouldn’t run multiple desktop screens to manage all your apps. Gnome Shell is no different, and provides an interesting take on these often-used workspaces.

With the Activities screen up, you’ll see a small round “+” icon in the bottom right corner of your screen. Click that to add new workspaces to your desktop.

Even though Gnome Shell is still in pretty early stages, they’ve already included some great usability features. For example, with the Activities up, you can click an application icon to launch in your current workspace, or drag the launch icon onto the appropriate workspace. So in the screenshot above, for example, I could drag the Firefox icon onto the third desktop to make it open there directly. Once a window is open, you can easily drag it from one workspace to the next. This video demonstrates exactly what I mean.

Sidebar

This is a nice little feature that’s not much right now but my guess is that it could evolve into a great little tool. If you click your username in the top right corner of the screen, you can choose to enable the Sidebar. If enabled, it sits at the left edge of the screen and can be collapsed to a thin bar or expanded into a small box by clicking the arrows at the top.

Eye Candy

The most obvious comparison for a composited window manger like Gnome Shell would be to Compiz. They’ve both got window animation effects for things like minimizing and opening windows, as well as transparencies and everything else you’d expect from a composited setup. The difference, so far at least, seems to me to be the purpose of those effects. Compiz puts much more emphasis on pure decoration like rain drops and wobbly windows whereas the Gnome Shell effects are generally more practical. That’s not to say Compiz doesn’t have some handy features, and this could all change as Gnome Shell development goes on.

Conclusion

My overall impression of Gnome Shell is most certainly positive. There’s clearly been a lot of thought put into its design, and some equally impressive coding behind the implementation. The visual effects are pleasing but not overwhelming, and the interface is very intuitive and takes almost no effort to understand.

That said, there’s still plenty of room for development. So far I’ve found essentially no configuration options of any kind, so at the moment it seems you’re stuck with having the shell exactly the way it was installed, like it or not. Fortunately for me, I like it. I’m sure configuration options will improve as development continues and more tools and features are added, so that’s not so much a complaint as a suggestion to be patient. It looks like it’ll be worth the wait.

Note – to use any of these prompts, you can copy & paste the “PS1=” line directly into your terminal. To make the change permanent, paste the line to the end of your ~/.bashrc file.

1. Show Happy face upon successful execution

This prompt is probably the most amusing one on the list, but remains useful. The idea is that as long as your commands execute successfully, your prompt shows a happy face. Any time a command fails, it shows a sad face instead.

Example:

Code:

PS1="\`if [ \$? = 0 ]; then echo \[\e[33m\]^_^\[\e[0m\]; else echo \[\e[31m\]O_O\[\e[0m\]; fi\`[\u@\h:\w]\\$ "

2.Change color on bad command

Here’s one of my favorites. This prompt has it all. Like above, the prompt changes color if your last command failed to run successfully, but it also shortens long paths and contains the bash history number of each command for easy retrieval.

Example:

Code:

PROMPT_COMMAND='PS1="\[\033[0;33m\][\!]\`if [[ \$? = "0" ]]; then echo "\\[\\033[32m\\]"; else echo "\\[\\033[31m\\]"; fi\`[\u.\h: \`if [[ `pwd|wc -c|tr -d " "` > 18 ]]; then echo "\\W"; else echo "\\w"; fi\`]\$\[\033[0m\] "; echo -ne "\033]0;`hostname -s`:`pwd`\007"'

3. Multi lines prompt

If you’re the type who wants to pack your prompt full of information, then here’s the one for you. This one is a multi-line prompt containing date/time, full path, user and host, active terminal, even file count and space usage.
Example:

Code:

PS1="\n\[\033[35m\]\$(/bin/date)\n\[\033[32m\]\w\n\[\033[1;31m\]\u@\h: \[\033[1;34m\]\$(/usr/bin/tty | /bin/sed -e 's:/dev/::'): \[\033[1;36m\]\$(/bin/ls -1 | /usr/bin/wc -l | /bin/sed 's: ::g') files \[\033[1;33m\]\$(/bin/ls -lah | /bin/grep -m 1 total | /bin/sed 's/total //')b\[\033[0m\] -> \[\033[0m\]"

4. Color manage your prompt

There’s nothing particularly fancy about this prompt, other than the good use of color to separate the different pieces of information. As you can see, it provides time, username, hostname, and current directory. Fairly minimal but useful.

Example:

Code:

PS1="\[\033[35m\]\t\[\033[m\]-\[\033[36m\]\u\[\033[m\]@\[\033[32m\]\h:\[\033[33;1m\]\w\[\033[m\]\$ "

5. Show full path

This one’s a nice, clean, minimal 2-line prompt (plus a blank line at the top). You’ve got your full path at the first line and pretty much just the username at the bottom. If you want to remove the blank line at the start of every prompt, just take out the first “\n”.

Example:

Code:

PS1="[\[\033[32m\]\w]\[\033[0m\]\n\[\033[1;36m\]\u\[\033[1;33m\]-> \[\033[0m\]"

6. Show background job count

Another nifty 2-liner, but this one’s got some info we haven’t used before. The first line is the normal user@host, with full path. On the second line we’ve got history number and a count of the jobs running in the background.

Example:

Code:

PS1='\[\e[1;32m\]\u@\H:\[\e[m\] \[\e[1;37m\]\w\[\e[m\]\n\[\e[1;33m\]hist:\! \[\e[0;33m\] \[\e[1;31m\]jobs:\j \$\[\e[m\] '

7. Display directory information

A very elegant and nice looking prompt design. With this one we’ve got user/host, number of jobs, and date/time on the top line. Below that is current directory along with number of files in that directory and their disk usage.

Example:

Code:

PS1="\n\[\e[30;1m\]\[\016\]l\[\017\](\[\e[34;1m\]\u@\h\[\e[30;1m\])-(\[\e[34;1m\]\j\[\e[30;1m\])-(\[\e[34;1m\]\@ \d\[\e[30;1m\])->\[\e[30;1m\]\n\[\016\]m\[\017\]-(\[\[\e[32;1m\]\w\[\e[30;1m\])-(\[\e[32;1m\]\$(/bin/ls -1 | /usr/bin/wc -l | /bin/sed 's: ::g') files, \$(/bin/ls -lah | /bin/grep -m 1 total | /bin/sed 's/total //')b\[\e[30;1m\])--> \[\e[0m\]"

8. My Prompt

And finally, the prompt I personally like to use. It’s a modification of #7, changed to take up less space and include only the information I most want in my prompt. I like the two-line style as it lets me see the full path without reducing the space for my actual commands.

Example:

Code:

PS1="\n\[\e[32;1m\](\[\e[37;1m\]\u\[\e[32;1m\])-(\[\e[37;1m\]jobs:\j\[\e[32;1m\])-(\[\e[37;1m\]\w\[\e[32;1m\])\n(\[\[\e[37;1m\]! \!\[\e[32;1m\])-> \[\e[0m\]"

If you’d like to share your prompt, please do so in the comments below.

There are many options to use with the bash history, some of them I use nearly every time I open a command shell. Today I’ll be covering some of the most useful aspects of the history, but I certainly won’t be able to cover them all.

Up/Down Arrows

Many of you probably know this one, but for anyone who doesn’t, it’ll make your life a lot easier. Any time you’re in the command shell, simply use the up and down arrows on your keyboard to move through the list of previously entered commands. Next time you enter a long command that turns out to have a typo, you don’t have to retype the whole thing just hit the up arrow and make whatever edits are needed.

!!

A similar feature to the one listed above is the double bang (!!). Those characters entered in the shell represent the last typed command. Let’s say you’re trying to run a command only to find out that you need root privileges to do it. Instead of retyping the whole command, you can simply enter

sudo !!

Bash will substitute the !! for the previous command, as in the example below.

This also works further backward, you can do something like

!-5

to recall the command 5 entries back in the history.

!(word)

Perhaps a few days ago you typed a long, complex command into your shell, for example a series of options for “wterm”. You can find and re-enter than command by using the history’s built in search. You simply add the first few letters of the command after the ! and bash will find it.

Be careful with this one. You may end up running something other than what you expected. Don’t use this for potentially dangerous commands like “rm” or “fdisk”.

!?(word)

This is similar to the last feature in that it searches the history for the word entered, but unlike !(word) this will find the word anywhere in the command, not just the beginning.

Be careful with this one. You may end up running something other than what you expected. Don’t use this for potentially dangerous commands like “rm” or “fdisk”.

Ctrl-R

This one may be my personal favorite history tool. It’s a bit like the !? item above, but interactive. In your command shell, hit Ctrl-R, and it will begin a search. As you type, bash will search the history and show you the results as you type. When it shows the command you want, simply hit enter and it will run that command. This can be safer than things like !? because you can see what the command will be before you run it, so you don’t have to guess or rely on memory.

Manual Search

Perhaps you don’t like the way Ctrl-R works, or you want to see ALL the commands you typed, or just the ones that contain a particular word. The history command will show you your full command history, along with the history number of each command (hold that thought, we’ll cover those numbers in a moment).

You can also specify the number of items the history command will show. To see the last 10 entries in the history, you could type

history 10

To see all history entries that contain a particular word, you can use grep to filter the results, like below.

!(number)

When you use the history command to view your command history list, you’ll notice each item in the list has a number associated with it. You can use that to recall that particular command. For example, item 87 could be run again by entering

!87

into your shell.

Word replacement

This one’s pretty great. How many times have you written out some big long command only to realize you put, say, hdd when you wanted hdc? Well bash has you covered. You can replace a word in the previous command with another using “^”, as in the example below

Managing Your History

By default, the history is saved in ~/.bash_history. You can deal with this file however you see fit, but there are some useful things you could try to manage it automatically. Namely, setting the environment variables HISTSIZE and HISTFILESIZE. To set the number of entries that can be saved in the history file to 1000, enter

export HISTFILESIZE=1000

into your shell. This will limit the file to 1000 entries. If you want to make this change permanent, put that export command into your .bashrc or .bash_profile file.

For those just starting out with Linux, or the command line specifically, the program that displays the command prompt and handles your commands is called bash, or the Bourne Again Shell. In this article we’ll be using the words command line and shell interchangeably to refer to interacting with Linux through bash.

Today we’ll be covering:

• Changing the shell startup routine
• Making a more useful command prompt
• Creating aliases for long or complex commands

.bashrc and .bash_profile

These two files are often the source of some confusion. At first appearance, they seem to do the exact same thing – running startup instructions every time you open a command prompt. In short, .bash_profile runs when you start a shell from a login screen (such as a console system login) and .bashrc runs for non-login shells (such as running Terminal from your system menu). The .bashrc file is the one you’ll be using the majority of the time so that’s the one we’ll use in our examples today.

As I said, .bashrc is loaded by bash whenever you open a new shell. Chances are you already have a .bashrc file that was created for you when you first installed your Linux system. To see what’s already in there, load up your preferred text editor and open

/home/YourUserName/.bashrc

(By default, the file is hidden from public view. You’ll have to right-click and select Show Hidden Files before it can show itself.)

You’ll probably see several lines of code, bash shell scripting to be precise, already in there. The default .bashrc in most distros has some code to do things like color prompts (which we’ll get into a little bit) and some handy aliases (which we’ll get into a lot).

Feel free to glance through the current contents of the file so you have an idea what’s already happening on each new shell session, but for the sake of this article we can safely ignore the current settings and just add what we want to the end.

Instead of putting our new items directly into the .bashrc file, we’re going to take a slightly different approach.  Each user on the system has their own .bashrc file in their home directory. If we wanted to make changes to the way bash runs, we’d have to place our changes in each of those files. If you later decide that what you did wasn’t quite what you wanted, you’d have to go through all of those files again and make your updates. Instead of all that hassle, we’re going to make a single file with all our custom settings, and just tell .bashrc to load from that file.  The diagram below demonstrates:

By placing the source command at the end of the .bashrc file, it will pull our commands in from the custom-shell.sh file and overwrite the default prompt and default aliases with the ones we’ve specified. This way, we can make a single file (/etc/custom-shell.sh or whatever else you’d like to name it) and just tell each user’s .bashrc file to load it. So if you’ve still got your .bashrc file loaded in your text editor, move all the way down to the bottom and add

source /etc/custom-shell.sh

Note – you can take this a step further and add the source line to the .bashrc file in /etc/skel. That way, all new users created on the system will already have our source line included!

Save the .bashrc file and then create a new, blank text file named custom-shell.sh.  This is where we’ll be putting all of the new settings in the following sections.

The Prompt

Every system has a default prompt. Usually, it’s a bland, default prompt with only a little bit of useful information.  It probably looks something like:

josh@roberts:~$

To test out exactly how prompt customisation is done, enter the following into the shell:

export PS1="Custom > "

This will turn your prompt into a simple arrow. No useful info of any kind, but it shows the basic idea of how you change the contents of your prompt.

Over the years, people have taken prompt customisation to the extreme, putting all kinds of info into it. I won’t go into a huge amount of detail on how to handle colors and multi-line prompts and adding live info, but I will give a nice looking, useful prompt that you could use as a base for your own. In the custom-shell.sh file we created earlier, paste in:

export PS1="\n\[\033[1;36m\]\u\[\033[1;37m\] \[\033[0;36m\]`date`\n\[\033[0m\][\[\033[1;33m\]\w\[\033[0m\]] "

Most of what you see there are color codes telling bash to switch back and forth between various colors for the text in the prompt. The end result of all this gibberish is a rather nice looking and easy to understand prompt.

Save the custom-shell.sh file after pasting in the code above. If you save it in /etc, you’ll probably need root privileges. You can save it anywhere you want, but make sure you point your .bashrc to the right place. To test out your new prompt, you can either close and re-open your shell, or just type

source .bashrc

into your current shell.

Your .bashrc file should read our new prompt info from the custom-shell.sh file and make your prompt nice and fancy with colors and all.

For an EXTREMELY detailed guide on prompt magic, see the Official Linux Prompt HOWTO.

Aliases

I might as well tell you up front – I love aliases. The first thing I do when I install a new system is set up my preferred aliases. As the name implies, an alias is just another name for a command. For example, my most used alias is one I call “gimme” which bash translates to “sudo apt-get install”. You can use aliases for a variety of reasons, such as shortening a long command or making the Linux shell act more like a Windows/Mac/Solaris/BSD/Whatever shell. I suggest pasting the following aliases into your custom-shell.sh file. Those who use distros other than Debian/Ubuntu style can translate the apt-get aliases into the appropriate yum command, or whatever package utility you prefer, and of course the same is true for aptitude and portage users.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

#
#Apt-related aliases
#
alias gimme="sudo apt-get install"            #Install new software
alias acs="apt-cache search"                    #Search available packages
alias purge="apt-get --purge remove"        #Removes package and its config files
alias update="sudo apt-get update"
alias debclean="sudo apt-get clean && sudo apt-get autoremove"  #Removes some unneeded files
#
#Misc useful aliases
#
alias ls="ls --color=auto"                           #Plain ls with color
alias ll="ls -l --color=auto"                         #Detailed list with color
alias config="dpkg-reconfigure"                #Re-run the configuration step for a package
alias cmi="./configure && make && sudo make install"    #Common steps to install package from source
alias numfiles="echo $(ls -1 | wc -l)"          #Count the number of files in current directory
alias dfree="df -h"                                       #See how much hard drive space is free in easy-to-read format
alias favdir="cd /directory/you/use/a/lot"   #Quickly switch to a directory you often need (music, documents, etc)

Add whatever else you think might be useful, or change the ones I’ve suggested to suit your needs. Instead of gimme and acs, you could use get and got. Some people transitioning from Windows like to make aliases to mimic Windows commands: copy to replace cp, move to replace mv, ipconfig to replace ifconfig, etc.

Your custom-shell.sh should now look something like this:

Once the custom-shell.sh file is saved, and .bashrc is set to point to it, re-open your command prompt and you should have a nice looking, useful prompt with several handy aliases to make things a little easier.

I would love to hear about you favorite aliases! Leave a comment and share some useful command shortcuts you’ve found, or maybe a nice prompt. The command line can be a very powerful tool, and I’d love to know ways you’ve found to make it even better.