Using These Prompts

Some of the following prompts are one-liners, and can be pasted directly into your terminal for (temporary) use. To make them permanent, you’ll have to paste the code into your .bashrc or .bash_profile.

The larger, more complex prompts such as Twtty should be saved to their own script file (such as myprompt.sh), and you place a line like

source myprompt.sh

in your .basrc file to “import” them.

Twtty Prompt

This is a two-line prompt that holds quite a bit of information including username, hostname, working directory, time, and command history number. Because of the technical and visual complexity, it’s best to place this prompt script in its own file, then source it from your .bashrc or .bash_profile as described above.

function prompt_command {
 
TERMWIDTH=${COLUMNS}
 
#   Calculate the width of the prompt:
 
hostnam=$(echo -n $HOSTNAME | sed -e "s/[\.].*//")
#   "whoami" and "pwd" include a trailing newline
usernam=$(whoami)
cur_tty=$(tty | sed -e "s/.*tty\(.*\)/\1/")
newPWD="${PWD}"
#   Add all the accessories below ...
let promptsize=$(echo -n "--(${usernam}@${hostnam}:${cur_tty})---(${PWD})--" \
                 | wc -c | tr -d " ")
let fillsize=${TERMWIDTH}-${promptsize}
fill=""
while [ "$fillsize" -gt "0" ] 
do 
    fill="${fill}-"
	let fillsize=${fillsize}-1
done
 
if [ "$fillsize" -lt "0" ]
then
   let cut=3-${fillsize}
	newPWD="...$(echo -n $PWD | sed -e "s/\(^.\{$cut\}\)\(.*\)/\2/")"
fi
}
 
PROMPT_COMMAND=prompt_command
 
function twtty {
 
local GRAY="\[\033[1;30m\]"
local LIGHT_GRAY="\[\033[0;37m\]"
local WHITE="\[\033[1;37m\]"
local NO_COLOUR="\[\033[0m\]"
 
local LIGHT_BLUE="\[\033[1;34m\]"
local YELLOW="\[\033[1;33m\]"
 
case $TERM in
    xterm*)
        TITLEBAR='\[\033]0;\u@\h:\w\007\]'
        ;;
    *)
        TITLEBAR=""
        ;;
esac
 
PS1="$TITLEBAR\
$YELLOW-$LIGHT_BLUE-(\
$YELLOW\$usernam$LIGHT_BLUE@$YELLOW\$hostnam$LIGHT_BLUE:$WHITE\$cur_tty\
${LIGHT_BLUE})-${YELLOW}-\${fill}${LIGHT_BLUE}-(\
$YELLOW\${newPWD}\
$LIGHT_BLUE)-$YELLOW-\
\n\
$YELLOW-$LIGHT_BLUE-(\
$YELLOW\$(date +%H%M)$LIGHT_BLUE:$YELLOW\$(date \"+%a,%d %b %y\")\
$LIGHT_BLUE:$WHITE\$$LIGHT_BLUE)-\
$YELLOW-\
$NO_COLOUR " 
 
PS2="$LIGHT_BLUE-$YELLOW-$YELLOW-$NO_COLOUR "
}

One important thing to note about this prompt is that the horizontal bar scales to fit the width of your terminal, and that the working directory line will truncate itself when it gets too large.

If you have any problems with the above code snippet, the plain text version can be downloaded here.

High-Performance Minimalist Prompt

All the complexities of a fancy prompt like Twtty do take up extra CPU cycles, and while it’s certainly not going to grind your system to a halt, it can add up. If you want something that packs a lot of info without slowing you down, I suggest this:

PS1="[\d | \T -> \w ...\$?]\n#"

One interesting thing to note here is the use of the variable $? at the end. This signifies the exit status of the last command entered. 0 means all is well, any other number usually indicates an error.

Rob’s Prompt

This is one of the more popular prompts floating around the Internet. The code is small and simple, yet it gives many of the features found in the larger, more complex examples.

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"

MegaFancyPrompt

The name is entirely deserved – this prompt is quite large and extremely fancy. It’s got color, titlebar control, user-awareness, proxy detection, screen detection, job count, and more. In short, just about every feature found in the other prompts we’ve mentioned can be found here, and quite a few others. If you want it ALL in your prompt, this is it.

Note: Not all features are visible at all times, so while it may not look like much in the screenshot, you can check out the full (documented, commented) script file here for details on how to get the visible parts you want.

COLOR_WHITE='\033[1;37m'
COLOR_LIGHTGRAY='033[0;37m'
COLOR_GRAY='\033[1;30m'
COLOR_BLACK='\033[0;30m'
COLOR_RED='\033[0;31m'
COLOR_LIGHTRED='\033[1;31m'
COLOR_GREEN='\033[0;32m'
COLOR_LIGHTGREEN='\033[1;32m'
COLOR_BROWN='\033[0;33m'
COLOR_YELLOW='\033[1;33m'
COLOR_BLUE='\033[0;34m'
COLOR_LIGHTBLUE='\033[1;34m'
COLOR_PURPLE='\033[0;35m'
COLOR_PINK='\033[1;35m'
COLOR_CYAN='\033[0;36m'
COLOR_LIGHTCYAN='\033[1;36m'
COLOR_DEFAULT='\033[0m'
 
# Function to set prompt_command to.
function promptcmd () {
    history -a 
    local SSH_FLAG=0
    local TTY=$(tty | awk -F/dev/ '{print $2}')
    if [[ ${TTY} ]]; then 
        local SESS_SRC=$(who | grep "$TTY "  | awk '{print $6 }')
    fi
 
    # Titlebar
    case ${TERM} in 
        xterm*  )  
            local TITLEBAR='\[\033]0;\u@\h: { \w }  \007\]'
            ;;
        *       )  
            local TITLEBAR=''                               
            ;;
    esac
    PS1="${TITLEBAR}"
 
    # Test for day change.
    if [ -z $DAY ] ; then
        export DAY=$(date +%A)
    else
        local today=$(date +%A)
        if [ "${DAY}" != "${today}" ]; then
            PS1="${PS1}\n\[${COLOR_GREEN}\]Day changed to $(date '+%A, %d %B %Y').\n"
            export DAY=$today
       fi
    fi
 
    # User
    if [ ${UID} -eq 0 ] ; then
        if [ "${USER}" == "${LOGNAME}" ]; then
            if [[ ${SUDO_USER} ]]; then
                PS1="${PS1}\[${COLOR_RED}\]\u"
            else
                PS1="${PS1}\[${COLOR_LIGHTRED}\]\u"
            fi
        else                               
            PS1="${PS1}\[${COLOR_YELLOW}\]\u"
        fi
    else
        if [ ${USER} == ${LOGNAME} ]; then     
            PS1="${PS1}\[${COLOR_GREEN}\]\u"
        else                               
            PS1="${PS1}\[${COLOR_BROWN}\]\u"
        fi
    fi
 
    # HTTP Proxy var configured or not
    if [ -n "$http_proxy" ] ; then
        PS1="${PS1}\[${COLOR_GREEN}\]@"
    else                               
        PS1="${PS1}\[${COLOR_LIGHTRED}\]@"
    fi
 
    # Host
 
    if [[ ${SSH_CLIENT} ]] || [[ ${SSH2_CLIENT} ]]; then 
        SSH_FLAG=1
    fi
    if [ ${SSH_FLAG} -eq 1 ]; then 
       PS1="${PS1}\[${COLOR_CYAN}\]\h "
    elif [[ -n ${SESS_SRC} ]]; then 
        if [ "${SESS_SRC}" == "(:0.0)" ]; then 
        PS1="${PS1}\[${COLOR_GREEN}\]\h "
        else 
            local parent_process=`cat /proc/${PPID}/cmdline`
            if [[ "$parent_process" == "in.rlogind*" ]]; then
                PS1="${PS1}\[${COLOR_BROWN}\]\h "
            elif [[ "$parent_process" == "in.telnetd*" ]]; then 
                PS1="${PS1}\[${COLOR_YELLOW}\]\h "
            else
                PS1="${PS1}\[${COLOR_LIGHTRED}\]\h "
            fi
        fi
    elif [[ "${SESS_SRC}" == "" ]]; then
        PS1="${PS1}\[${COLOR_GREEN}\]\h "
    else                                 
        PS1="${PS1}\[${COLOR_RED}\]\h " 
    fi
 
    # Detached Screen Sessions
    local DTCHSCRN=$(screen -ls | grep -c Detach )
    if [ ${DTCHSCRN} -gt 2 ]; then
        PS1="${PS1}\[${COLOR_RED}\][scr:${DTCHSCRN}] "
    elif [ ${DTCHSCRN} -gt 0 ]; then
        PS1="${PS1}\[${COLOR_YELLOW}\][scr:${DTCHSCRN}] "
    fi
 
    # Backgrounded running jobs
    local BKGJBS=$(jobs -r | wc -l )
    if [ ${BKGJBS} -gt 2 ]; then
        PS1="${PS1}\[${COLOR_RED}\][bg:${BKGJBS}]"
    elif [ ${BKGJBS} -gt 0 ]; then
        PS1="${PS1}\[${COLOR_YELLOW}\][bg:${BKGJBS}] "
    fi
 
    # Stopped Jobs
    local STPJBS=$(jobs -s | wc -l )
    if [ ${STPJBS} -gt 2 ]; then
        PS1="${PS1}\[${COLOR_RED}\][stp:${STPJBS}]"
    elif [ ${STPJBS} -gt 0 ]; then
        PS1="${PS1}\[${COLOR_YELLOW}\][stp:${STPJBS}] "
    fi
 
    # Bracket {
    if [ ${UID} -eq 0 ]; then              
        if [ "${USER}" == "${LOGNAME}" ]; then 
            if [[ ${SUDO_USER} ]]; then
                PS1="${PS1}\[${COLOR_RED}\]"
            else
                PS1="${PS1}\[${COLOR_LIGHTRED}\]"
            fi
        else                               
            PS1="${PS1}\[${COLOR_YELLOW}\]"
        fi
    else                                 
        if [ "${USER}" == "${LOGNAME}" ]; then 
            PS1="${PS1}\[${COLOR_GREEN}\]"
        else                               
            PS1="${PS1}\[${COLOR_BROWN}\]"
        fi
    fi
    PS1="${PS1}{ "
 
    # Working directory
    if [ -w "${PWD}" ]; then 
        PS1="${PS1}\[${COLOR_GREEN}\]$(prompt_workingdir)"
    else                                 
        PS1="${PS1}\[${COLOR_RED}\]$(prompt_workingdir)"
    fi
 
    # Closing bracket } and $\#
    if [ ${UID} -eq 0 ]; then              
        if [ "${USER}" == "${LOGNAME}" ]; then 
            if [[ ${SUDO_USER} ]]; then
                PS1="${PS1}\[${COLOR_RED}\]"
            else
                PS1="${PS1}\[${COLOR_LIGHTRED}\]"
            fi
        else                               
            PS1="${PS1}\[${COLOR_YELLOW}\]"
        fi
    else                                 
        if [ "${USER}" == "${LOGNAME}" ]; then 
            PS1="${PS1}\[${COLOR_GREEN}\]"
        else                               
            PS1="${PS1}\[${COLOR_BROWN}\]"
        fi
    fi
    PS1="${PS1} }\$\[${COLOR_DEFAULT}\] "
}     
 
# Trim working dir to 1/4 the screen width
function prompt_workingdir () {
  local pwdmaxlen=$(($COLUMNS/4))
  local trunc_symbol="..."
  if [[ $PWD == $HOME* ]]; then
    newPWD="~${PWD#$HOME}" 
  else
    newPWD=${PWD}
  fi
  if [ ${#newPWD} -gt $pwdmaxlen ]; then
    local pwdoffset=$(( ${#newPWD} - $pwdmaxlen + 3 ))
    newPWD="${trunc_symbol}${newPWD:$pwdoffset:$pwdmaxlen}"
  fi
  echo $newPWD
}
 
# Determine what prompt to display:
# 1.  Display simple custom prompt for shell sessions started
#     by script.  
# 2.  Display "bland" prompt for shell sessions within emacs or 
#     xemacs.
# 3   Display promptcmd for all other cases.
 
function load_prompt () {
    # Get PIDs
    local parent_process=$(cat /proc/$PPID/cmdline | cut -d \. -f 1)
    local my_process=$(cat /proc/$$/cmdline | cut -d \. -f 1)
 
    if  [[ $parent_process == script* ]]; then
        PROMPT_COMMAND=""
        PS1="\t - \# - \u@\H { \w }\$ "
    elif [[ $parent_process == emacs* || $parent_process == xemacs* ]]; then
        PROMPT_COMMAND=""
        PS1="\u@\h { \w }\$ "
    else
        export DAY=$(date +%A)
        PROMPT_COMMAND=promptcmd
     fi 
    export PS1 PROMPT_COMMAND
}
 
load_prompt

Bonus – Finding the Right Colors

As you may have noticed, most of these prompts use color, and the color is often represented in a coded form like ‘\033[1;30m’, which is quite difficult to read or remember. An easy way to see all your available colors, and preview what they’ll look like, is to simply paste the following snippet into your browser:

for i in `seq 1 7 ; seq 30 48 ; seq 90 107 ` ; do 
    echo -e "\e[${i}mtest\e[0m$i" 
done

Which will output each color code with its number.

Conclusion

There are, of course infinite variations that could be packed into your prompt. Nearly any kind of textual data can be added in, and bash’s developers have had decades to add in functionality. Some readers have even commented about running custom Python or Ruby scripts from within the prompt. Whatever you do, make it functional, and if it’s REALLY cool, drop us a link in the comments!

Related Posts:

• The Beginner Guide to Writing Linux Shell Scripts
• 10 Useful Tools, Websites And Tricks to Help You Master Linux Command
• 8 Useful and Interesting Bash Prompts
• How to Get a Quake-style Drop-down Terminal in Linux

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!

Related Posts:

• 8 Useful and Interesting Bash Prompts
• Mastering the Bash History
• Making The Linux Command Line A Little Friendlier
• More Useful and Interesting Bash Prompts

How it Works

The most common RVM setup goes something like this – A user installs RVM as an application, either system-wide or within their home. Through RVM, the user’s chosen Ruby versions are installed automatically into that user’s home. Using RVM commands, the user specifies which version they’d like to have active at any given time. All calls made to Ruby during that time are routed to the appropriate Ruby executable and run as normal. There’s no virtualization or complex wrappers or chroots to worry about, it acts more-or-less like a clever series of symlinks and environment variables that direct all Ruby calls to the chosen version.

Installation

First we need a few prerequisites. Your standard Ubuntu installation should contain much of what’s needed, but some needed packages may be missing. To build RVM properly, install the following packages from Ubuntu Software Center or from the command line with:

sudo apt-get install git build-essential bison openssl libreadline6 libreadline6-dev curl git-core zlib1g zlib1g-dev libssl-dev libyaml-dev libsqlite3-0 libsqlite3-dev sqlite3 libxml2-dev libxslt-dev autoconf libc6-dev

This readies our system to properly build and install RVM and Ruby. We won’t need to do the usual configure/make routine on this one as RVM actually includes a simple build script which should do the work for you. Once all the above dependencies are installed, run the following from the command line:

bash < <( curl http://rvm.beginrescueend.com/releases/rvm-install-head )

This will fetch the source and deliver a nice message from RVM’s developer.

Adding a Ruby Version

At this point you’ve got RVM but no usable Ruby install to run with it. Getting RVM to install one is as simple as a single shell command. For the first example, we’ll install the 1.8.7 stable version from source with one RVM command:

rvm install 1.8.7

RVM will handle the entire process including configuration, compilation and the installation of RubyGems.

Post-Install

Once complete, there’s a little bit of environment setup we’ve got to do. For RVM to be able to properly intercept Ruby calls, we’ve got to add the following line to .bashrc or .bash_profile:

[[ -s "$HOME/.rvm/scripts/rvm" ]] && . "$HOME/.rvm/scripts/rvm"

Restart your shell and it should take effect. To test, just enter

type rvm | head -1

Which should respond with “rvm is a function”. If not, something’s broken along the line.

Managing Ruby Versions

Now that everything is set up, we can actually use RVM! Assuming you’ve installed version 1.8.7 as in the example above, it can be selected with

rvm use 1.8.7

RVM should give you a response confirming your choice and showing you the location of the Ruby executable. This can be verified later using the standard system which command.

Additional versions can be installed the same way, and gems can be added and removed from RVM versions exactly as they would in a normal system Ruby install. You can pick your version on the fly to be sure your app works as intended without ever worrying about conflicts and environment mismatches. Enjoy!

Related Posts:

• How to Integrate Skype With Ubuntu Unity
• How to Install Java Runtime In Ubuntu 12.04
• How to Connect to A VPN In Ubuntu [Quick Tips]
• How to Upgrade to Gimp 2.8 in Ubuntu

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.

Related Posts:

• 8 Useful and Interesting Bash Prompts
• Making The Linux Command Line A Little Friendlier
• The Beginner Guide to Writing Linux Shell Scripts
• How to Multitask at the Linux Command Line with Screen

Regardless which camp you belong, as long as you are using Linux (doesn’t matter which distro), you are sure to hit the terminal and type some commands into it at some point of time. Why not embrace it and take the opportunity to learn something new?

Here are some websites, tools and tricks that you can make use of to learn Linux command line. This is in no way a comprehensive list, but will be a good start for those who wish to get started.

Note: The “command line” stated here can refer to the bash commands you type in the terminal, or writing your own bash scripts.

Website

1. Linux Command.org

LinuxCommand.org is a site on… you guess it, Linux command. If you know absolutely nothing about the command line, this is a good starting ground. LinuxCommand is more like a school, where it teaches you from the basic, such as “what is a shell?” to simple command usage and lastly, advanced techniques like “how to write your own shell scripts“.

http://linuxcommand.org

2. CommandLineFu

There are often cases when you want to get things done on the terminal, but can’t remember the exact code. When such cases occur, a good place to check out is CommandLineFu. Just think of a social network for command line and you get CommandLineFu. CommandlineFu is the place where people share the commonly used bash code so you just have to copy/paste the code to the terminal instead of writing your own. It is also a great way to discover the infinite possibilities that you can do on the terminal.

CommandlineFu

3. ShellFu

Similar to CommandlineFu, ShellFu is also a place where you can find plenty of codes, examples and uses of the command line. What makes it different is that ShellFu is more like a blog (rather than a social network), is moderated and there is no vote up/down feature.

ShellFu

4. O’Reilly Linux Command and SS64

O’Reilly Linux Command and SS64 bash are both a good place to go if you need just a quick reference of a particular command. All the commands are sorted in alphabetical order, so you can easily find the commands you want.

O’Reilly Linux Command
SS64

Tools

5. CLI Companion

CLI Companion is a replacement for your default terminal. It is divided into two panes. The upper pane is a library of the commonly used bash command and the lower pane is the actual terminal. You can scroll through the library to find the command you want, right click on it and select “Apply”. The command will get executed in the terminal below.

In Ubuntu, you can install via the command:

sudo add-apt-repository ppa:clicompanion-devs/clicompanion-nightlies

sudo apt-get update

sudo apt-get install clicompanion

6. Ebook – Bash Guide For Beginners

For beginners who like to learn bash command on the move, a good way is to download the free ebook – Bash Guide For Beginners and read it on your mobile devices. The ebook contains (almost) every single things you need to know about bash command. Even if you are experience with bash command, it never hurts to have a ebook by your side where you can refer from time to time.

Bash Guide For Beginners

Tricks

Here are some tricks that you can use to increase your productivity.

7. Bash Autocompletion

One easy way to get around bash is to use the autocompletion feature. When you are halfway through typing a command, you just have to press the “Tab” button on your keyboard and it will autocomplete your command for you. If it can’t understand your command, it will show a list of options for you to choose.

8. Creating alias

If you frequently use the same command over and over again, it is a good idea to add an alias for that command. An alias is just a short for a (long) command. 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.

Creating bash alias

9. Mastering the bash history

The bash history contains the list of the commands that you have used before. To access your bash history, the simplest way is to use the Up/Down arrow key in the terminal. More bash history tricks can be found at the link below.

Mastering bash history

10. Using of bash prompt

Bash prompt is the result that appears when you enter a bash command. Most people are using the default system setting (gray color), not knowing that they can change the prompt settings and get it to display additional information and colors.

bash prompt

As I said above, this is by no means the most comprehensive list around and I am sure there are plenty of other useful websites, tools and tricks that I have left out. Do tell us about it in the comments.

Related Posts:

• Knowing Your Linux System Via the Command Line
• How to Get a Quake-style Drop-down Terminal in Linux
• Making The Linux Command Line A Little Friendlier
• 10 More Funny and/or Useless Linux Commands

Pastebin 101

For those who’ve never used pastebin, it’s a very simple service. You enter in some text, and the website saves it to its own location. That’s it. You, or anyone else who has that URL, can view the text. It’s meant to be used by programmers and such to share things like code snippets and log messages. Fortunately, it lets you choose how long your text will remain on the server. If we save our .bashrc here, we can always return to it later to get what we need. You can choose, when saving your file, how long to keep the files stored on Pastebin.com.

If you stop here and just go the normal route, your file will be given an URL like http://pastebin.com/d535effd9. That’s not so easy to remember, so we go one step further and use…

“Private” Pastebin

A clever feature to Pastebin.com is that it allows you to create your own personal subdomain on the fly. For example, instead of going to just http://pastebin.com, you use your name as a subdomain (ie http://joshprice.pastebin.com) you’ll get your own little section to leave your text. Now, the word “private” is quotes here because there’s nothing keeping anyone else from accessing that same “private” area. In fact, if you have a common name and you try the method I suggested, you may find that someone else is already placing files there. Keep toying around until you can find something unique.

As you can see, the title now shows that we’re in my own private pastebin. Once again, there is nothing stopping anyone else from accessing that location and adding/changing files, it’s just a name space you can use to access things you’ve saved.

You may notice that the “Recent Posts” section in the top-left now shows only the posts in this private space. I can go back here in a year and see all the notes I’ve saved so far (presuming I told them to live that long, and no one else has changed them).

Saving Your .bashrc

Fill up your .bashrc (or whatever else you’d like to save on pastebin) with the settings you want. If you haven’t already, create a unique private space as described in the previous section. Paste in the contents of your file, choose how long you’d like to to stay on the server, and hit Send. You’ll be taken to the URL of your text file, which you can save or send to others.

Retrieving Your .bashrc

There are a few ways you could go about putting your file back on your system once the install is complete.

Simplest - Open your private pastebin address and the post you’re looking for. Highlight all the text, open your exising .bashrc file and add the pastebin info to the end.

Command Line - From your browser, open your private pastebin address and the post you’re looking for. You’ll see a Download button in the header bar above your post. Right-click the link and choose “Copy Link Location” (or your browser’s equivalent). From the command line, enter

wget -O ~/.bashrc (pastebin link location)

to save the file from pastebin directly into the local .bashrc file, overwriting the existing contents. If you’re able to remember the URL of your file so you don’t have to open the website, this may be the fastest method, and it wouldn’t require a browser at all.

Recommended - Open your private pastebin address and the post you’re looking for. You’ll see a Download button in the header bar above your post. Instead of 826492.txt or whatever filename it gives you, save it in your home as something like bashrc-custom. You can add the line

source bashrc-custom

to the existing .bashrc file, so that you get all the shell options the distro included as well as your customizations.

Related Posts:

• How to Supercharge Your Shell with Bashish [Linux]
• 10 Useful Tools, Websites And Tricks to Help You Master Linux Command
• How to Get a Quake-style Drop-down Terminal in Linux
• Sudo vs Su [Linux] (MTE Explains)

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.

Related Posts:

• Making The Linux Command Line A Little Friendlier
• The Beginner Guide to Writing Linux Shell Scripts
• How to Supercharge Your Shell with Bashish [Linux]
• Mastering the Bash History

I had always set a special desktop just for my terminals. Readers of some of my other articles may have noticed that when setting up virtual desktops, I always set Desktop #2 for my terminals. I typically have more than one open, so they have their own desktop workspace. I put it in between my Browser and Text workspaces because I’m frequently copy/pasting to and from those other workspaces so it makes sense to be next to each other. When a friend suggested I try Yakuake (thanks AWOL!) I was a bit reluctant, as my current setup had always worked so well. I installed it anyway, and within a week I was converted.

To see why, let’s get Yakuake installed. On Ubuntu or any other Debian-style distribution, open a regular terminal and type in:

sudo apt-get install yakuake

You could of course use whatever package installation method you prefer.

Once installed, run

yakuake &

from the command line. The “&” at the end is just a bash code to run this program in the background so you can still use your current terminal screen even while Yakuake is running.

Once it loads up you’ll be shown a notice that the program is started. You’ll also be given an option to change which key is used to make the menu appear. By default, it’s set to F12 but you can set it to whatever you’d like. Of course, it’s a good idea to pick a key you don’t normally use in other programs.

Once that’s done, hit F12 or whatever other key you specified to make the terminal appear. It should look something like this:

Pretty good, but it could be better. To improve Yakuake’s functionality, there are a few preferences we can set. To open the configuration screen, look in the bottom right corner for the button shown here:

This will open the menu where you can choose “Configure Yakuake”. There are a decent number of config options to choose from.

On the first page, the one titled Window, you can set things like the size of the Yakuake window. If you don’t use the terminal much, then it might be wise to set the width to something smaller than the default 90%. Something like 50% might be more appropriate. If, like me, you tend to use the terminal often, I’d suggest leaving the window nice and wide because (as we’ll cover in a moment) the Yakuake window can be split into panes, so you can fit 2, 4, however many terminals you like into the single Yakuake window.

The next configuration page is the Behavior config. On here, I’d suggest unchecking “Keep window open when it loses focus”. Having this unchecked will make Yakuake disappear as soon as you click away onto another program. I also tend to remove the option for “Show startup notification popup”. Otherwise you’ll get a little notice in the corner every time the program loads. Personally, I don’t see a point in that.

The final config page is the Appearance section. Everything on there is pretty self-explanatory so I won’t go into much detail on that, except to say that you can enable translucency to get a nice semi-transparent look to your Yakuake window. It requires you to be running X with compositing enabled (which should be the default on most modern setups).

The last feature I’d like to cover is one I mentioned earlier in this article, the ability to split the Yakuake window into multiple terminal sessions. That’s easily done by right-clicking the “+” icon in the bottom-left corner of the Yakuake window. You can choose how to arrange those terminals inside the window if you have a preference between, say, a horizontal split or a vertical split.

You can also left-click the “+” button to have multiple terminals in tabs instead of split screen if you want the full window space for one terminal.

Have you used Yakuake or something similar in the past? How has it worked out for you? I’d love to hear your thoughts in the comments.

Related Posts:

• 10 Useful Tools, Websites And Tricks to Help You Master Linux Command
• Sudo vs Su [Linux] (MTE Explains)
• How to Start With Vim [Linux]
• Knowing Your Linux System Via the Command Line

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.

Related Posts:

• The Beginner Guide to Writing Linux Shell Scripts
• 8 Useful and Interesting Bash Prompts
• Making The Linux Command Line A Little Friendlier
• How to Remove Recent History Lists In Ubuntu 11.10

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.

Related Posts:

• 8 Useful and Interesting Bash Prompts
• The Beginner Guide to Writing Linux Shell Scripts
• 7 Linux Shell Tips For Increased Productivity
• How to Supercharge Your Shell with Bashish [Linux]