Once upon a time, Unix had only one shell, the Bourne shell, and when a
script was written, the shell read the script and executed the
commands. Then another shell appeared, and another. Each shell had its
own syntax and some, like the C shell, were very different from the
original. This meant that if a script took advantage of the features of
one shell or another, it had to be run using that shell. Instead of
typing:

doit

The user had to know to type:

/bin/ksh doit

or:

/bin/csh doit

To remedy this, a clever change was made to the Unix kernel -- now a
script can be written beginning with a hash-bang (#!) combination on
the first line, followed by a shell that executes the script. As an example, take a look at the following script, named doit:

#! /bin/ksh
#
# do some script here
#

In this example, the kernel reads in the script doit, sees the hash-bang, and continues reading the rest of the line, where it finds /bin/ksh.
The kernel then starts the Korn shell with doit as an argument and
feeds it the script, as if the following command had been issued:

/bin/ksh doit

When /bin/ksh begins reading in the script, it sees the hash-bang in the first line as a comment (because it starts with
a hash) and ignores it. To be run, the full path to the shell is required, as the
kernel does not search your PATH variable. The hash-bang handler in the
kernel does more than just run an alternate shell; it actually takes
the argument following the hash-bang and uses it as a command, then
adds the name of the file as an argument to that command.

You could start a Perl script named doperl by using the hash-bang:

#! /bin/perl

# do some perl script here

If you begin by typing doperl, the kernel spots the hash-bang,
extracts the /bin/perl command, then runs it as if you had typed:

/bin/perl doperl

There are two mechanisms in play that allow this to work. The first is
the kernel interpretation of the hash-bang; the second is that
Perl sees the first line as a comment and ignores it. This technique
will not work for scripting languages that fail to treat lines starting
with a hash as a comment; in those cases, it will most likely cause an error. You needn't limit your use of this method to running scripts either, although that is where it's most useful.

The following script, named helpme, types itself to the terminal when
you enter the command helpme:

#! /bin/cat
vi     unix editor
man    manual pages
sh     Bourne Shell
ksh    Korn Shell
csh    C Shell
bash   Bourne Again Shell

This kernel trick will execute one argument after the name of the
command. To hide the first line, change the file to use more by
starting at line 2, but be sure to use the correct path:

#! /bin/more +2
vi     unix editor
man    manual pages
sh