Actually, these are very good questions and i am glad that you asked. It is always much more satisfying to teach someone willing to learn.

These are different language constructs. First the "$(( ... ))": this means: replace the numeric expression inside by its outcome. For instance you could write

Code:

foo -x $(( 5 - 3 + 1 ))

and this would be the same as

Code:

foo -x 3

The shell doesn't differentiate between numeric and string variables, at least not in the sense a high-level language does. Consider the following lines:

Code:

z=0
x="abc5"
x="${x#???}"    # this chops off the first 3 characters, leaving "5"
(( z = x * 5 ))
echo $z

I started the variable as string, then manipulated it like a string and finally, because its value was numeric, used it like an integer. So, if you want to make clear to the shell that the following is a numeric operation, you signify this by "(( ... ))". You can add "$" in front to replace it with its outcome in another line.

The other device, "$( ... )" is a subshell: it runs the commands inside in a separate shell and (the "$" in front) replaces it with its outcome (which could well be a string, it doesn't have to be numeric). It is the same device which is used at the end of the command:

Code:

>(cut -d\  -f1|uniq | wc -l >/dev/stderr )

Which means: run all the commands inside in a separate shell, directing something to the "stdin" input device of this shell (the ">").

Yes, there is: the is the "-a" switch of "tee". I suggest you enter "man tee" to read its man page, which usually will also contain some examples.

First, the redirection to "stderr" is only happening with the very last commands output. Before this, it is always "stdout" to "stdin". In fact the pipe symbol "|" means: connect the "stdout" of the first process to "stdin" of the second process.

Whe i told you about UNIX processes being like garden hoses, this was a simplified picture of reality: in fact all the UNIX commands are more like "Y-shaped garden hoses". They have a "stdin" where data are puored in, but 2 outputs (one "stdout" for normal output, the other "stderr" usually used for error messages), which can both be directed anywhere separately. For instance:
connect the stdout

Code:

ls -l /etc/passwd /some/file/blabla

will produce an error message because "/some/file/blabla" doesn't exist. This error message is going through "stderr" and usually it lands on the screen because both "stdin" and "stderr" are both pointing to the same device per default. That in fact they are from different sources is easy to see once we redirect one of these sources away:

Code:

ls -l /etc/passwd /some/file/blabla > /dev/null
ls -l /etc/passwd /some/file/blabla 2> /dev/null

Notice the difference in output. "/dev/null" is simply the catch-all device. It works like a black hole: whatever goes in is lost, out comes nothing.

Now, to make sure both output streams are separated from each other and are displayed one after the other (not mixed up) it is a good idea to let the one output go to "stdout", the other to "stderr". There are also some intricate differences (buffered versus unbuffered output) i don't think you will grasp for now. I hope you understand that i forego the explanation of some very advanced stuff to a newbie. Still, it is impressing that you came up with this very good question.

First, "kill" is used to send signals to a process. "kill" is a regular command and has a man page i suggest you read. It takes a process number as an argument, to which it sends a signal. As there is no signal specified "kill" will send its default signal, which is "TERM" - it asks the process to close down. "$!" is a special variable maintained by the shell and holds the process ID of the last process started in background. So, this command terminates the last started background process.

I hope this helps.

bakunin