May the source be with you, but remember the KISS principle ;-)

Contents Bulletin Scripting in shell and Perl Network troubleshooting History Humor

Arithmetic Expressions in BASH


See also

Recommended  Links

Arithmetic expressions Double square bracket conditionals Single sqare bracket conditionals
Compound comparisons Integer comparison operators String comparison operators File test operators Quoting caveats Macro substitutions caveats
if statements in shell Loops in Shell Case statement in shell Shell History Humor Etc

Older UNIX shells like Borne shell  and ksh88 have clumsy, inefficient way of doing arithmetic based on external expr command:

z=`expr $z + 3` 

When Perl arrived, it became clear that such approach is inferior on modern computers and actually increases overhead of shell instead of decreasing it. So ksh93 was created to fight back the lost ground. While it failed to stop Perl, ksh93 was a big improvement, and later bash (starting from version 3.2) re-implemented most of the advanced features of ksh93 plus a couple of its own.  Currently bash is restricted to integer arithmetic while ksh93 can do floating-point arithmetic as well.

In bash version 3.2 and later you can (and should) use $(( )) or let for integer arithmetic expressions and conditionals. The idea of ((...)) construct is similar to [[...]] construct  introduced in ksh88. It provides built in capabilities for arithmetic that are superior to calling external function expr (or test in case of conditionals).

The ((...)) conditional expression evaluates an arithmetic expression like it was written in a "normal" algorithmic language (you can even omit dollar signs from the variables) and sets the exit status to 1 if the expression evaluates to 0, or to 0 if the expression evaluates to a non-zero value.  For example:

(( uid == 0 ))
(( uid > 1000 ))

You can use multiple expressions connected with operations AND or OR. That make it the new standard was to program integer comparisons in if statements, while loops and similar control flow constructs. Old [[...]] construct should no longer be used: it just does not make any sense anymore outside string comparisons.  For example

 (( percent >= 0 && percent 	<= 100 ))

Another  example:

 (( uid > 10  &&  uid < 100  )) # arithmetic condition

As long as you can limit yourself to integer arithmetic, you can use all the standard C-language operators inside of  ((...)) conditionals. Here is a more complex examples, that demonstrates that not always we can get rid of leasing $ in arithmetic expressions:

function mess
   if (( "$1" > 0 )) ; then
   tail -$total /var/adm/messages | more

All arithmetical operations are performed  on integers. For example:

	i=$(( i + 1 ))
	let i+=1


	i=$(( i++))
	let i++

In case of assignments, there must be no spaces around the equals sign. Generally in shells line bash or ksh93 spaces are treated as in any normal algorithmic language: they are optional.  Not not in this case and that a gotcha that you need to be aware of: a space before equal sign confuses bash into thinking that this is a function invocation. For example, in case of

	i = $(( i + 5 )) # not what you think!

bash will try to run a program named i and its first argument would be an equal sign, and its second argument would be the number you get adding 5 to the value of $i.

Another idiosyncrasy is that so called  R-value rule ($ should be prefixed to the shell variable on the right side of assignment statement to get its value) is optional and generally you should never use $ prefix for variables in ((..)) construct.  That means that

let i=$i+1

should be written as in regular programming languages:

let i=i+1 

The gotcha is that you still need the dollar sign for positional parameters (e.g.,$2) to distinguish it from a numeric constant (e.g., "2"). Here's an example:

i=$(( i + $2 ))

There is a several C-style shortcuts supported by BASH. The most useful is probably  +=  (familiar to any programmer). That means that:

let i=$i+5

can be written as

let i+=5
Usual C-style increments/decrements  ++/--  are available  too:
let $i++
(( $i++ ))

Shortcuts for assignment operators in bash

Operator Operation with assignment Use Meaning
= Simple assignment a=b a=b
*= Multiplication a*=b a=(a*b)
/= Division a/=b a=(a/b)
%= Remainder a%=b a=(a%b)
+= Addition a+=b a=(a+b)
-= Subtraction a-=b a=(a-b)
<<= Bit-shift left a<<=b a=(a<<b)
>>= Bit-shift right a>>=b a=(a>>b)
&= Bitwise "and" a&=b a=(a&b)
^= Bitwise "exclusive or" a^=b a=(a^b)
|= Bitwise "or" a|=b a=(a|b)

The assignments can  be cascaded, through the use of the comma operator:

	echo $(( i+=2 , j++ ))

which will do both assignments and then echo the result of the second expression (since the comma operator returns the value of its second expression).

Quotes or backslashes  usually are not needed  inside of the $(( )) construct:
all characters between the (( and )) are treated as string in double quotes.

The differences between the ((...)) command and let command

While constructs are almost identical there some minor differences. I would prefer to use ((..)) in both conditional expressions  and assignment statements as let construct contains a couple of unpleasant gotchas:

let i+=5
All-in-all despite warts this is a considerable improvement over what we used to have and newer versions of bash should be used whenever possible.  I would like to remind again that before ksh93 introduced let and (( ... )) commands, the only way to perform arithmetic was with expr. For example, to do the same increment to variable i you need to write:
i=`expr $i + 5` 
The ((...)) construct can (and should) be used in any control statements such as if, headers of loop and case statement. for example:
function mess
   if (( "$1" > 0 )) ; then
   tail -$total /var/adm/messages | more
Here are some additional examples (Internal Commands and Builtins)
Letting let do arithmetic.


let a=11            # Same as 'a=11'
let a=a+5           # Equivalent to  let "a = a + 5"
                    # (Double quotes and spaces make it more readable.)
echo "11 + 5 = $a"  # 16

let "a <<= 3"       # Equivalent to  let "a = a << 3"
echo "\"\$a\" (=16) left-shifted 3 places = $a"
                    # 128

let "a /= 4"        # Equivalent to  let "a = a / 4"
echo "128 / 4 = $a" # 32

let "a -= 5"        # Equivalent to  let "a = a - 5"
echo "32 - 5 = $a"  # 27

let "a *=  10"      # Equivalent to  let "a = a * 10"
echo "27 * 10 = $a" # 270

let "a %= 8"        # Equivalent to  let "a = a % 8"
echo "270 modulo 8 = $a  (270 / 8 = 33, remainder $a)"
                    # 6

# Does "let" permit C-style operators?
# Yes, just as the (( ... )) double-parentheses construct does.

let a++             # C-style (post) increment.
echo "6++ = $a"     # 6++ = 7
let a--             # C-style decrement.
echo "7-- = $a"     # 7-- = 6
# Of course, ++a, etc., also allowed . . .

# Trinary operator.

# Note that $a is 6, see above.
let "t = a<7?7:11"   # True
echo $t  # 7

let a++
let "t = a<7?7:11"   # False
echo $t  #     11


Using Array Variables

Bash, at last, provides one-dimensional indexed and associative array variables. They can be declared implicitly (contextually) or explicitly. To explicitly declare an array, use

     declare -a name

Initialization of arrays in bash has format similar to Perl:

	solaris=(serv01 serv02 serv07 ns1 ns2)

Each element of the array is a separate word in the list enclosed in parentheses. Then you can refer to each this way:

	echo solaris is installed on ${solaris[2]}

If you omit index writing  and use command "echo $solaris" you will get the first element too.

Another example taken from Bash Shell Programming in Linux
array=(red green blue yellow magenta)
echo "The array has $size members. They are:"
while [ $i -lt $size ]; do
	echo "$i: ${array[$i]}"
	let i++
Run this example:
$ ./
The array has 5 members. They are:
0: red
1: green
2: blue
3: yellow
4: magenta

The (( ...)) construct is also used in bash for a new form of  for loop syntax, one that looks a lot like C Language:

for (( i=1; 
i<=n; i++ )) 
   touch file$i 

for (( ; ; )) 
   echo "infinite loop [ hit CTRL+C to stop]" 

Its more general form this new, C-like loop can be described as:

for (( expr1 ; expr2 ; expr3 )) ; do list ; done

The use of double parentheses indicates that expressions can use syntax of ((..)) construct.  several iteration counters can be used. For example:

for (( i=0, j=0 ; i < 10 ; i++, j++ ))
    echo $((i*j))

That for loop initializes two variables (i and j), then has a more complex second expression adding the two together before doing the less-than comparison. The comma operator is used again in the third expression to increment both variables.

Here are some additional examples from Advanced Bash scripting guide:

Example 10-12. A C-like for loop
for ((a=1; a <= LIMIT ; a++))  # Double parentheses, and "LIMIT" with no "$".
  echo -n "$a "
done                           # A construct borrowed from 'ksh93'.

echo; echo

# +=========================================================================+

# Let's use the C "comma operator" to increment two variables simultaneously.

for ((a=1, b=1; a <= LIMIT ; a++, b++))  # The comma chains together operations.
  echo -n "$a-$b "

echo; echo

exit 0

Top updates

Bulletin Latest Past week Past month
Google Search


Old News ;-)

Please visit  Heiner Steven's SHELLdorado, the best shell scripting site on the Internet

[Nov 21, 2010] Integer Arithmetic

Both Bash and the Korn shell support evaluating arithmetic expressions without arithmetic expansion. The syntax is similar to $((...)) but without the dollar sign. Because expansion is not performed, the construct can be used without variable assignment or the colon operator:

$ x=10
$ ((x = x * 12))
$ echo $x

The real value of this construct is that it allows arithmetic expressions to be used rather than test in if, while, and until commands. The comparison operators set the exit status to a nonzero value if the result of the comparison is false and to a zero value if the result is true. So writing

(( i == 100 ))

has the effect of testing i to see whether it is equal to 100 and setting the exit status appropriately. This knowledge makes integer arithmetic ideal for inclusion in if commands:

if (( i == 100 ))

The (( i == 100 )) returns an exit status of zero (true) if i equals 100 and one (false) otherwise, and has the same effect as writing

if [ "$i" -eq 100 ]

One advantage of using ((...)) rather than test is the capability to perform arithmetic as part of the test:

if (( i / 10 != 0 ))

Here the comparison returns a true if i divided by 10 is not equal to zero.

while loops can also benefit from integer arithmetic. For example,

while ((x++ < 100))

executes commands 100 times. (Note that some older versions of the Korn shell and Bash do not support the ++ and -- operators.)

Integer Types

The Korn shell and Bash both support an integer data type. You can declare variables to be integers by using the typeset command with the -i option

typeset -i variables

where variables are any valid shell variable names. Initial values can be assigned to the variables at the time they are declared.

Arithmetic performed on integer variables with the ((...)) construct is slightly faster than on noninteger ones because the shell internally stores the value of an integer variable as a binary number and not as a character string.

An integer variable cannot be assigned anything but an integer value or an integer expression. If you attempt to assign a noninteger to it, the message bad number is printed by the Korn shell:

$ typeset -i i
$ i=hello
ksh: i: bad number

Bash simply ignores any strings that don't contain numeric values and generates an error for anything that contains both numbers and other characters:

$ typeset -i i
$ i=hello
$ echo $i
$ i=1hello
bash: 1hello: value too great for base (error token is "1hello")
$ i=10+15
$ echo $i

The preceding example shows that integer-valued expressions can be assigned to an integer variable, without even having to use the ((...)) construct. This holds true for both Bash and the Korn shell.

Numbers in Different Bases

The Korn shell and Bash allow you to perform arithmetic in different bases. To write a number in a different base with these shells, you use the notation


For example, to express the value 100 in base 8 (octal) you write


You can write constants in different bases anywhere an integer value is permitted. To assign octal 100 to the integer variable i, you can write

typeset -i i=8#100

Note that with the Korn shell the base of the first value assigned to an integer variable fixes the base of all subsequent substitutions of that variable. In other words, if the first value you assign to the integer variable i is an octal number, each time you subsequently substitute the value of i on the command line, the Korn shell substitutes the value as an octal number using the notation 8#value.

$ typeset -i i=8#100
$ echo $i
$ i=50
$ echo $i
$ (( i = 16#a5 + 16#120 ))
$ echo $i

Because the first value assigned to i in this example is an octal number (8#100), all further substitutions of i will be in octal. When the base 10 value of 50 is next assigned to i and then i is subsequently displayed, we get the value 8#62, which is the octal equivalent of 50 in base 10.

In the preceding example, the ((...)) construct is used to add together the two hexadecimal values a5 and 120. The result is then displayed, once again in octal.

Bash uses both the base#number syntax for arbitrary bases and the C language syntax for octal and hexadecimal numbers—octal numbers are preceded by 0 (zero), and hexadecimal numbers are preceded by 0x:

$ typeset -i i=0100
$ echo $i
$ i=0x80
$ echo $i
$ i=2#1101001
$ echo $i
$ (( i = 16#a5 + 16#120 ))
$ echo $i

Unlike the Korn shell, Bash doesn't keep track of the variable's base; integer variables are displayed as decimal numbers. You can always use printf to print integers in octal or hexadecimal format.

[Nov 21, 2010] Advanced Bash Shell Scripting Guide - Operators

Arithmetic operators often occur in an expr or let expression.

Example 8-2. Using Arithmetic Operations

# Counting to 11 in 10 different ways.

n=1; echo -n "$n "

let "n = $n + 1"   # let "n = n + 1"  also works.
echo -n "$n "

: $((n = $n + 1))
#  ":" necessary because otherwise Bash attempts
#+ to interpret "$((n = $n + 1))" as a command.
echo -n "$n "

(( n = n + 1 ))
#  A simpler alternative to the method above.
#  Thanks, David Lombard, for pointing this out.
echo -n "$n "

n=$(($n + 1))
echo -n "$n "

: $[ n = $n + 1 ]
#  ":" necessary because otherwise Bash attempts
#+ to interpret "$[ n = $n + 1 ]" as a command.
#  Works even if "n" was initialized as a string.
echo -n "$n "

n=$[ $n + 1 ]
#  Works even if "n" was initialized as a string.
#* Avoid this type of construct, since it is obsolete and nonportable.
#  Thanks, Stephane Chazelas.
echo -n "$n "

# Now for C-style increment operators.
# Thanks, Frank Wang, for pointing this out.

let "n++"          # let "++n"  also works.
echo -n "$n "

(( n++ ))          # (( ++n )  also works.
echo -n "$n "

: $(( n++ ))       # : $(( ++n )) also works.
echo -n "$n "

: $[ n++ ]         # : $[ ++n ]] also works
echo -n "$n "


exit 0
Integer variables in Bash are actually signed long (32-bit) integers, in the range of -2147483648 to 2147483647. An operation that takes a variable outside these limits will give an erroneous result.
echo "a = $a"      # a = 2147483646
let "a+=1"         # Increment "a".
echo "a = $a"      # a = 2147483647
let "a+=1"         # increment "a" again, past the limit.
echo "a = $a"      # a = -2147483648
                   #      ERROR (out of range)

As of version 2.05b, Bash supports 64-bit integers. Bash does not understand floating point arithmetic. It treats numbers containing a decimal point as strings.


let "b = $a + 1.3"  # Error.
# let: b = 1.5 + 1.3: syntax error in expression (error token is ".5 + 1.3")

echo "b = $b"       # b=1
Use bc in scripts that that need floating point calculations or math library functions.

[Jun 19, 2008] Bash Arrays  by Mitch Frazier

Linux Journal

If you're used to a "standard" *NIX shell you may not be familiar with bash's array feature. Although not as powerful as similar constructs in the P languages (Perl, Python, and PHP) and others, they are often quite useful.

Bash arrays have numbered indexes only, but they are sparse, ie you don't have to define all the indexes. An entire array can be assigned by enclosing the array items in parenthesis:

  arr=(Hello World)
Individual items can be assigned with the familiar array syntax (unless you're used to Basic or Fortran):
But it gets a bit ugly when you want to refer to an array item:
  echo ${arr[0]} ${arr[1]}
To quote from the man page:
The braces are required to avoid conflicts with pathname expansion.

In addition the following funky constructs are available:

  ${arr[*]}         # All of the items in the array
  ${!arr[*]}        # All of the indexes in the array
  ${#arr[*]}        # Number of items in the array
  ${#arr[0]}        # Length if item zero
The ${!arr[*]} is a relatively new addition to bash, it was not part of the original array implementation.

The following example shows some simple array usage (note the "[index]=value" assignment to assign a specific index):


array=(one two three four [5]=five)

echo "Array size: ${#array[*]}"

echo "Array items:"
for item in ${array[*]}
    printf "   %s\n" $item

echo "Array indexes:"
for index in ${!array[*]}
    printf "   %d\n" $index

echo "Array items and indexes:"
for index in ${!array[*]}
    printf "%4d: %s\n" $index ${array[$index]}
Running it produces the following output:
Array size: 5
Array items:
Array indexes:
Array items and indexes:
   0: one
   1: two
   2: three
   3: four
   5: five

Note that the "@" sign can be used instead of the "*" in constructs such as ${arr[*]}, the result is the same except when expanding to the items of the array within a quoted string. In this case the behavior is the same as when expanding "$*" and "$@" within quoted strings: "${arr[*]}" returns all the items as a single word, whereas "${arr[@]}" returns each item as a separate word.

The following example shows how unquoted, quoted "*", and quoted "@" affect the expansion (particularly important when the array items themselves contain spaces):


array=("first item" "second item" "third" "item")

echo "Number of items in original array: ${#array[*]}"
for ix in ${!array[*]}
    printf "   %s\n" "${array[$ix]}"

echo "After unquoted expansion: ${#arr[*]}"
for ix in ${!arr[*]}
    printf "   %s\n" "${arr[$ix]}"

echo "After * quoted expansion: ${#arr[*]}"
for ix in ${!arr[*]}
    printf "   %s\n" "${arr[$ix]}"

echo "After @ quoted expansion: ${#arr[*]}"
for ix in ${!arr[*]}
    printf "   %s\n" "${arr[$ix]}"
When run it outputs:
Number of items in original array: 4
   first item
   second item

After unquoted expansion: 6

After * quoted expansion: 1
   first item second item third item

After @ quoted expansion: 4
   first item
   second item

Mitch Frazier is the System Administrator at Linux Journal.

Arithmetic expansion with double parentheses, and using let 

The use of backticks (backquotes) in arithmetic expansion has been superseded by double parentheses -- ((...)) and $((...)) -- and also by the very convenient let construction.
z=$((z+3))                                  #  Also correct.
                                            #  Within double parentheses,
                                            #+ parameter dereferencing
                                            #+ is optional.

# $((EXPRESSION)) is arithmetic expansion.  #  Not to be confused with
                                            #+ command substitution.

# You may also use operations within double parentheses without assignment.

  echo "n = $n"                             # n = 0

  (( n += 1 ))                              # Increment.
# (( $n += 1 )) is incorrect!
  echo "n = $n"                             # n = 1

let z=z+3
let "z += 3"  #  Quotes permit the use of spaces in variable assignment.
              #  The 'let' operator actually performs arithmetic evaluation,
              #+ rather than expansion.

Recommended Links

Softpanorama Top Visited

Softpanorama Recommended

Please visit  Heiner Steven SHELLdorado  the best shell scripting site on the Internet

Advanced Bash-Scripting Guide Turn Vim into a bash IDE


Linux tip Bash test and comparison functions

Common shell script mistakes


Examples shipped with bash 3.2 and newer
Path Description X-ref
Deprecated sample implementation of a bash debugger.  
Shell completion code.  
Example functions.  
Various array functions (ashift, array_sort, reverse).  
Convert an array to a string.  
An almost ksh-compatible 'autoload' (no lazy load). ksh
An almost ksh-compatible 'autoload' (no lazy load). ksh
A more ksh-compatible 'autoload' (with lazy load). ksh
A replacement for basename(1). basename
Fast basename(1) and dirname(1) functions for bash/sh. basename, dirname
Start, control, and end co-processes.  
Control shell co-processes (see coprocess.bash).  
README for coshell and coproc.  
A C-shell compatibility package. csh
Directory manipulation functions from the book The Korn Shell.  
A replacement for dirname(1). dirname
Find out if a directory is empty.  
Display the exit status of processes.  
Like command, but forces the use of external command.  
Recursive factorial function.  
Front-end to sync TERM changes to both stty(1) and readline 'bind'. stty.bash
Print out definitions for functions named by arguments.  
Get a web page from a remote server (wget(1) in bash).  
getopt function that parses long-named options.  
Internet address conversion (inet2hex and hex2inet).  
Return zero if the argument is in the path and executable. inpath
Test user input on numeric or character value.  
Test user input on numeric values, with floating point.  
Test user input for valid IP addresses.  
Julian date conversion.  
Look for running jobs.  
Try to keep some programs in the foreground and running.  
ksh-like cd: cd [-LP] [dir[change]]. ksh
ksh-like arithmetic test replacements. ksh
Functions and aliases to provide the beginnings of a ksh environment for bash ksh
Replace the login and newgrp built-ins in old Bourne shells.  
Rename files to lowercase. rename lower
Find and print a manpage. fman
Print MH folders, useful only because folders(1) doesn't print mod date/times.  
Notify when jobs change status.  
Path related functions (no_path, add_path, pre-path, del_path). path
Recursive directory traverser.  
A clone of the C shell built-in repeat. repeat, csh
A clone of the C shell built-in repeat. repeat, csh
Generate a sequence from m to n;m defaults to 1.  
Generate a sequence from m to n;m defaults to 1.  
Readline-based pager. cat, readline pager
Readline-based pagers. cat, readline pager
Sort the positional parameters.  
A function to emulate the ancient ksh built-in. ksh
A function to emulate the ancient ksh built-in. ksh
A shell function to set the terminal type interactively or not.  
An implementation of the 10th Edition Unix sh built-in whatis(1) command.  
An almost ksh-compatible whence(1) command.  
An emulation of which(1) as it appears in FreeBSD.  
Convert csh alias commands to bash functions. csh, aliasconv
A find(1) clone.  
Example loadable replacements.  
Return nondirectory portion of pathname. basename
cat(1) replacement with no options—the way cat was intended. cat, readline pager
cut(1) replacement.  
Return directory portion of pathname. dirname
Print file info.  
POSIX.2 getconf utility.
Replacement definitions for ones the system doesn't provide.  
Copy first part of files.  
Obligatory "Hello World" / sample loadable.  
POSIX.2 user identity.  
Make links.  
Print login name of current user.  
Simple makefile for the sample loadable built-ins.  
Make directories.  
echo without options or argument interpretation.  
Check pathnames for validity and portability.  
Loadable ksh-93 style print built-in.  
Minimal built-in clone of BSD printenv(1).  
Anyone remember TOPS-20?  
Canonicalize pathnames, resolving symlinks.  
Remove directory.  
Sleep for fractions of a second.  
Loadable built-in interface to strftime(3).  
Sync the disks by forcing pending filesystem writes to complete.  
Duplicate standard input.  
Example template for loadable built-in.  
True and false built-ins.  
Return terminal name.  
Print system information.  
Remove a directory entry.  
Print out username of current user.  
Illustrates how to build a Perl interpreter into bash.  
Convert csh aliases to bash aliases and functions. csh, xalias
Convert csh aliases to bash aliases and functions. csh, xalias
Convert csh aliases, environment variables, and variables to bash equivalents. csh, xalias
SunView TERMCAP string.  
Modified version of the Korn Shell debugger from Bill Rosenblatt's Learning the Korn Shell.
Noah Friedman's collection of scripts (updated to bash v2 syntax by Chet Ramey).  
Pseudo-arrays and substring indexing examples.  
Library functions used by require.bash.  
./scripts.noah/bash_version. bash 
A function to slice up $BASH_VERSION.  
Enable and disable eight-bit readline input.  
Make a temporary file with a unique name.  
A fun hack to translate numerals into English.  
Permissions to use the scripts in this directory.  
A way to set PS1 to some predefined strings.  
A front end to bind to redo readline bindings. readline
Lisp-like require/provide library functions for bash.  
Replacement SMTP client written in bash.  
bash replacement for cat(1). cat
Replacement for source that uses current directory.  
The string(3) functions at the shell level.  
Front-end to stty(1) that changes readline bindings too. fstty
Prompt for a yes/no/quit answer. ask
John DuBois' ksh script collection (converted to bash v2 syntax by Chet Ramey).  
Convert an arc archive to a compressed tar archive.  
Random number generator with upper and lower bounds and optional seed. random
Convert a day number to a name.  
cd replacement with a directory stack added.  
Tell what produced a core file.  
Fast man(1) replacement. manpage
Copy files using ftp(1) but with rcp-type command-line syntax.  
Change filenames to lowercase. rename lower
A nicer front end for cp(1) (has -i, etc)..  
Change the extension of a group of files. rename
A nicer front end for mv(1) (has -i, etc).. rename
Print specified pages from files.  
Permissions to use the scripts in this directory.  
A pager front end that handles compressed files.  
Poor man's top(1) for SunOS 4.x and BSD/OS.  
Rename files by changing parts of filenames that match a pattern. rename
Change the names of files that match a pattern. rename
Execute a command multiple times. repeat
Line profiler for bash scripts.  
Unarchive a (possibly compressed) tarfile into a directory.  
Carefully uudecode(1) multiple files.  
uuencode(1) multiple files.  
Print a visual display of a directory tree. tree
Show where commands that match a pattern are.  
Example scripts.  
Text adventure game in bash!  
Bourne shell's C shell emulator. csh
Readline-based pager. cat, readline pager
Center a group of lines.  
Line editor using only /bin/sh, /bin/dd, and /bin/rm.  
Recurse a tree and fix files containing various bad characters.  
The inevitable Towers of Hanoi in bash.  
Search $PATH for a file the same name as $1; return TRUE if found. inpath
Produces a random number within integer limits. random
Line input routine for GNU Bourne Again Shell plus terminal-control primitives.  
bash version of nohup command.  
Test relative precedences for && and || operators.  
Print a random card from a card deck. random
Display scrolling text.  
Display scrolling text.  
A self-reproducing script (careful!).  
Convert ls(1) symbolic permissions into octal mode.  
Display a prompt and get an answer satisfying certain criteria. ask
Display a spinning wheel to show progress.  
Give rsh(1) a shorter timeout.  
Display a tree printout of the direcotry with disk use in 1k blocks. tree
Display a graphical tree printout of dir. tree
Display a graphical tree printout of dir. tree
A web server in bash!  
Print the contents of the xterm title bar.  
Emulate printf (obsolete since printf is now a bash built-in).  
Example startup files.  
Some useful aliases (written by Fox).  
Sample startup file for bash login shells (written by Fox).  
Sample startup file for bash login shells (written by Ramey).  
Sample Bourne Again Shell init file (written by Ramey).  
Sample Bourne Again Shell init file (written by Fox).  
Example startup files for Mac OS X.  
Sample aliases for Mac OS X.  
Sample User preferences file.  
Sample Bourne Again Shell environment file.  
Sample login wrapper.  
Sample logout wrapper.  
Sample Bourne Again Shell config file.  



Groupthink : Understanding Micromanagers and Control Freaks : Toxic Managers : BureaucraciesHarvard Mafia : Diplomatic Communication : Surviving a Bad Performance Review : Insufficient Retirement Funds as Immanent Problem of Neoliberal Regime : PseudoScience : Who Rules America : Two Party System as Polyarchy : Neoliberalism  : The Iron Law of Oligarchy : Libertarian Philosophy


Skeptical Finance : John Kenneth Galbraith : Keynes : George Carlin : Skeptics : Propaganda  : SE quotes : Language Design and Programming Quotes : Random IT-related quotes : Oscar Wilde : Talleyrand : Somerset Maugham : War and Peace : Marcus Aurelius : Eric Hoffer : Kurt Vonnegut : Otto Von Bismarck : Winston Churchill : Napoleon Bonaparte : Ambrose Bierce : Oscar Wilde : Bernard Shaw : Mark Twain Quotes


Vol 26, No.1 (January, 2013) Object-Oriented Cult : Vol 25, No.12 (December, 2013) Rational Fools vs. Efficient Crooks: The efficient markets hypothesis : Vol 25, No.08 (August, 2013) Cloud providers as intelligence collection hubs : Vol 23, No.10 (October, 2011) An observation about corporate security departments : Vol 23, No.11 (November, 2011) Softpanorama classification of sysadmin horror stories : Vol 25, No.05 (May, 2013) Corporate bullshit as a communication method : Vol 25, No.10 (October, 2013) Cryptolocker Trojan (Win32/Crilock.A) : Vol 25, No.06 (June, 2013) A Note on the Relationship of Brooks Law and Conway Law


Fifty glorious years (1950-2000): the triumph of the US computer engineering : Donald Knuth : TAoCP and its Influence of Computer Science : Richard Stallman : Linus Torvalds  : Larry Wall  : John K. Ousterhout : CTSS : Multix OS Unix History : Unix shell history : VI editor : History of pipes concept : Solaris : MS DOSProgramming Languages History : PL/1 : Simula 67 : C : History of GCC developmentScripting Languages : Perl history   : OS History : Mail : DNS : SSH : CPU Instruction Sets : SPARC systems 1987-2006 : Norton Commander : Norton Utilities : Norton Ghost : Frontpage history : Malware Defense History : GNU Screen : OSS early history

Classic books:

The Peter Principle : Parkinson Law : 1984 : The Mythical Man-MonthHow to Solve It by George Polya : The Art of Computer Programming : The Elements of Programming Style : The Unix Hater’s Handbook : The Jargon file : The True Believer : Programming Pearls : The Good Soldier Svejk : The Power Elite

Most popular humor pages:

Manifest of the Softpanorama IT Slacker Society : Ten Commandments of the IT Slackers Society : Computer Humor Collection : BSD Logo Story : The Cuckoo's Egg : IT Slang : C++ Humor : ARE YOU A BBS ADDICT? : The Perl Purity Test : Object oriented programmers of all nations : Financial Humor : Financial Humor Bulletin, 2008 : Financial Humor Bulletin, 2010 : The Most Comprehensive Collection of Editor-related Humor : Programming Language Humor : Goldman Sachs related humor : Greenspan humor : C Humor : Scripting Humor : Real Programmers Humor : Web Humor : GPL-related Humor : OFM Humor : Politically Incorrect Humor : IDS Humor : "Linux Sucks" Humor : Russian Musical Humor : Best Russian Programmer Humor : Microsoft plans to buy Catholic Church : Richard Stallman Related Humor : Admin Humor : Perl-related Humor : Linus Torvalds Related humor : PseudoScience Related Humor : Networking Humor : Shell Humor : Financial Humor Bulletin, 2011 : Financial Humor Bulletin, 2012 : Financial Humor Bulletin, 2013 : Java Humor : Software Engineering Humor : Sun Solaris Related Humor : Education Humor : IBM Humor : Assembler-related Humor : VIM Humor : Computer Viruses Humor : Bright tomorrow is rescheduled to a day after tomorrow : Classic Computer Humor


The Last but not Least

Copyright © 1996-2014 by Dr. Nikolai Bezroukov. was created as a service to the UN Sustainable Development Networking Programme (SDNP) in the author free time. This document is an industrial compilation designed and created exclusively for educational use and is distributed under the Softpanorama Content License. Site uses AdSense so you need to be aware of Google privacy policy. Original materials copyright belong to respective owners. Quotes are made for educational purposes only in compliance with the fair use doctrine. This is a Spartan WHYFF (We Help You For Free) site written by people for whom English is not a native language. Grammar and spelling errors should be expected. The site contain some broken links as it develops like a living tree...

You can use PayPal to make a contribution, supporting hosting of this site with different providers to distribute and speed up access. Currently there are two functional mirrors: (the fastest) and


The statements, views and opinions presented on this web page are those of the author and are not endorsed by, nor do they necessarily reflect, the opinions of the author present and former employers, SDNP or any other organization the author may be associated with. We do not warrant the correctness of the information provided or its fitness for any purpose.

Last modified: February, 19, 2014