merging mgregson's patch to the ssh section and minor typos
[kspaans/UnixTutorial] / holy-fuck-a-shell.pod
1 =head1 Welcome to Unix
2
3 Welcome to the unix environment. Here you have the familiar point
4 and click gui, but thats not why you're reading this, you're here for
5 the shell. So what is this mysterious shell you've been told about by
6 upper year students? It is a command line interface to your computer.
7 Where the gui is like pointing and grunting the shell is using language.
8 A beginner might not do much better than pointing and grunting, but with
9 practice one can control a computer with the skill of a poet.
10
11 =head2 A few useful keys before we begin
12
13 As you've probably guessed the shell is a command line interface that
14 you type into. It's essentially an interactive programming language,
15 like the interactions window in DrScheme, but designed to operate on
16 the system and work in a rather diverse environment. Its also designed
17 for convinence, and as you'll discover, quite powerful. Before we get
18 started there are a few keystrokes you'll need to be aware of.
19
20 First, the commands that you type in can be editted, similar to a line of
21 text in a text editor.  You can move the cursor left and right, erase text
22 (both delete and backspace work as you're familiar with from your word
23 processor, and ctrl+k will delete everything to the right of the cursor),
24 and scroll through your I<command history> (using the up arrow and down
25 arrow for back and forwards respctively).
26
27 If you want to view your command history use the command C<history>. To run
28 an old command type C<!number> where number is the number next to the 
29 command in history.
30
31 Most shells also provide tab completion of commands and file names, to
32 use this just press tab after typing part of a file path or command, as long
33 as it's unique. If it's not the shell will show you all the possibilities
34 (this may be a rather long list).
35
36 =head2 Getting to the Shell
37
38 There are several ways to access the shell remotely and locally. Remote
39 shells can be obtained by connecting to a server with a program called
40 Secure Shell or ssh. If you're local to a linux or unix system just start
41 any of the many terminal programs. (On OS-X, look for Terminal in
42 Applications>Utilities.  On Ubuntu look in the Applications menu under
43 Accessories.)
44
45 =head3 From Windows
46
47 Unlike the other operating systems discussed here, Windows does not have
48 a built in Unix-like shell.  There are several applications that provide
49 Unix-like shell features on Windows, but the
50
51 There are several utilities that can provide access to ssh from Windows, 
52 the main one used by people at Waterloo is PuTTY 
53 L<http://www.chiark.greenend.org.uk/~sgtatham/putty/>. There is also a
54 program called Cygwin L<http://cygwin.org>. It provides a Linux-like
55 environment in Windows. You use it inside of a command-prompt window. So it's
56 just like using PuTTY, except you don't have to be online to use it. Make sure
57 the ssh package is installed, and then just type ssh.
58
59 =for commentary
60
61 What exactly did you want this to discuss? --mgregson
62
63 This is fine --ebering
64
65 =cut
66
67 =head3 From Mac OS-X
68
69 Mac OS X comes with X11 (more on X11 later) installed, and with X11 comes
70 a unix shell with most of the features discussed here, including an 
71 ssh client. There is also a Terminal.app that you
72 can find in /Applications/Utilities. It doesn't require that you start X11, but
73 then you don't get the advantage of X11 forwarding. But that's an advanced
74 topic that will be discussed later. You can also use many of the non student
75 environment commands on your mac. Like most Unix-like operating systems, OS-X 
76 comes with a built in ssh client. All you need to do to connect using SSH is to 
77 open up Terminal and type in ssh user@host.  (Go on, give it a try.)
78
79 =head3 From Linux
80
81 To connect to the student environment from linux just start a terminal program
82 and use ssh like on OS-X, ssh will be documented in its own section. Also
83 most of the things in this guide are useable on your local terminal as well.
84
85 =head3 ssh(1) 
86
87 The ssh utility is invoked from your local command line like this
88
89  $ssh username@hostname
90
91 At this point you will be prompted for your password. For the student.cs
92 environment hostname is student.cs.uwaterloo.ca or just student.cs from
93 inside the network. Your user name is your quest id.
94
95 =head4 ssh keys (optional)
96
97 ssh can be configured to log in automatically without prompting you for your
98 password using cryptographic keys to authenticate. To set this up do the 
99 following:
100
101  $ssh-keygen -t dsa
102  Generating public/private dsa key pair.
103  Enter file in which to save the key (~/.ssh/id_dsa): 
104  Enter passphrase (empty for no passphrase): 
105  Enter same passphrase again: 
106  Your identification has been saved in ~/.ssh/id_dsa.
107  Your public key has been saved in ~/.ssh/id_dsa.pub.
108  The key fingerprint is:
109  <some numbers> user@host
110  $ssh-keygen -t rsa
111  Generating public/private rsa key pair.
112  Enter file in which to save the key (~/.ssh/id_rsa): 
113  Enter passphrase (empty for no passphrase): 
114  Enter same passphrase again: 
115  Your identification has been saved in ~/.ssh/id_rsa.
116  Your public key has been saved in ~/.ssh/id_rsa.pub.
117  The key fingerprint is:
118  <some numbers> user@host
119  $ssh-copy-id user@host
120  user@host's password: 
121
122 This is optional and more detail can be found in the man page. More
123 on those in the next section...
124
125 Also, please keep in mind that while the passphrase can be, and too often is,
126 left blank, this poses an enormous security risk and should only be done if
127 you are 100% certain you are the only person who will be using the computer
128 in question, and your hard drive is encrypted.
129
130 =head2 Getting Help
131
132 Now that you can log in easily (or at least login if you skipped the section on 
133 keys) you're probably wondering what you can do, we'll get to that, but first 
134 a way to get help beyond this guide. For most commands (which are just 
135 programs) the authors often include manual or man pages (the good ones anyway) 
136 documenting how to use the program. To access this information use the C<man> 
137 command like this:
138
139  $man <command name>
140
141 There are also manual entries on various system calls and program libraries, 
142 configuration files, and system daemons. These are in different numbered 
143 sections, type C<man man> for more information.
144
145 =head2 Thats all well and good, what can I do?
146
147 Like we said earlier, the shell can be used to command a computer. So anything 
148 you could do in graphical programs you can do on the shell and more. Many shell 
149 tools don't translate well to pointing and clicking, just like its hard to read 
150 a poem to a caveman. Commands don't function in a vaccum though, they take 
151 input a variety of ways. The first is standard input, normally attached to your 
152 keyboard (but it can be moved around), the second is command line arguments and 
153 flags. Arguments are just placed after the command, and the man page can 
154 explain which flags are avaiable and how to use them. Two common ones are 
155 C<--help> and C<--verbose> which have obvious functions. The third input method 
156 is reading from various files, some specified on the command line some searched 
157 for by default.
158
159 We'll start with some basic file tools and command and control abilities.
160
161 =for commentary
162
163 Should we perhaps define "file system"?
164
165 =cut
166
167 =head2 The file system and what to do about it
168
169 Programs are just files on disk and manipulate data which is also on the disk, 
170 so it obviously follows that the most important programs are the ones for 
171 working with files on the disk. This section will go over the file system and 
172 these important programs.
173
174 =head3 The file system is organized into directories
175
176 The file system in the unix environment starts with C</> or the root, different 
177 drives are all attached as directories under the root. For now don't worry 
178 about drives and lets chat about directories. In unix everything has a running 
179 or "working" directory, including your shell prompt. To see what your current 
180 directory is use the B<p>rint B<w>orking B<d>irectory command C<pwd> at the 
181 prompt. This will give you the I<absolute path> to your working directory. Any 
182 I<relative paths> you specify will be relative to this location. To go 
183 somewhere else use the B<c>hange B<d>irectory command C<cd> followed by the 
184 path you wish to change to. With no arguments it takes you to your home 
185 directory. The path specified can be relative or absolute.
186
187 =over
188
189 =item I<absolute paths>
190
191 Absolute paths are specified starting from the system root and look like 
192 C</this/path/is/absolute>. Absolute paths are important when working with 
193 other people or when going somewhere completely different on the filesystem, 
194 really anywhere precision is needed.
195
196 =item I<relative path>
197
198 Relative paths are specified relative to your (or a program's) current working 
199 directory and are just like they sound. They start without a C</> (remember 
200 that C</> specifies the system root) and otherwise work exactly the same. There 
201 are a few special directories that can be used in relative paths, the first is 
202 C<.> which stands for the current directory. The second is C<..> which is the 
203 directory above the current directory. Here are some examples:
204
205  $pwd
206  /home/user
207  $cd /etc/games
208  $pwd
209  /etc/games
210  $cd ../config
211  $pwd
212  /etc/config
213  $cd network/
214  $pwd
215  /etc/config/network
216  $cd ..
217  $pwd
218  /etc/config
219  $cd ./network
220  $pwd
221  /etc/config/network
222
223 =back
224
225 Which directories exist isn't set in stone, you B<r>eB<m>ove B<dir>ectories 
226 with the C<rmdir> command, and B<m>aB<k>e them with C<mkdir>. C<rmdir> takes an 
227 existing path and removes the directory (you can't remove one with anything in 
228 it). C<mkdir> takes a valid path and makes a directory.
229
230 Paths may seem confusing, but they are a rather straightforeward way of 
231 specifying both directory locations and filenames. How do you specify a filename 
232 you ask? Just like a directory. If you're in C</path/to> and want a file called 
233 C<afile> all you need to do is write C<afile>. If you're somewhere else you can 
234 get to it absolutely C</path/to/afile> or use any of the other things mentioned 
235 in path specification to name it.
236
237 =head3 Files, they're people too
238
239 Speaking of files, you probably want to see them. The first step to seeing 
240 files is seeing where they are, the command for this is the B<l>iB<s>t command 
241 C<ls>, which shows the files in your current directory, as well as directories. 
242 C<ls> might be set up for colour coded output, it might not be, the man page 
243 can explain how to set that up. C<ls> also has a B<l>ong format, viewed using 
244 C<ls -l>, which provides a lot of useful information about the files listed. 
245 Again the man pages can give you more information.
246
247 Now that you know the names of your files you might want to actually get at 
248 their contents. The simplest way is C<cat> which takes a file name and spits 
249 out the contents to the screen. This is nice for short files, but you can't
250 scroll back. Two commands that give you a little more control are C<head> 
251 and C<tail> which display the start and end of files. C<tail> is particularly 
252 useful in watching log files using the B<f>ollow flag C<-f>, which watches the 
253 file for updates and displays the new entries as they appear. A third way to 
254 view files, which is perahps the most convinient, is something known as a 
255 I<pager> program. There are many pagers, this author's favorite is C<less>, 
256 which takes a filename argument and lets you scroll up and down as well as 
257 search. To search in less type C</> followed by what you're looking for. To 
258 find more matches press C<n> to go foreward and C<N> to go back. In less 
259 C</> actually takes a pattern, to learn about those check the man pages or 
260 the text manipulation and editing tutorial.
261
262 You might be asking how to create files now. Lots of programs create files 
263 as output, there are logs, data files, random crap, so what you probably 
264 want is a way to edit text. Thats easy, use C<pico> or C<nano> for simple 
265 command like editors. However these editors are rather simple and lack power, 
266 for a full introduction to the vast text editing capabilities refer to the 
267 text manipulation and editing tutorial.
268
269 Files can also be B<m>oB<v>ed around, B<c>oB<p>ied and B<r>eB<m>oved. The 
270 commands C<mv> and C<cp> do moving and copying, taking the original filename 
271 as the first argument and the destination as the second. If the second is a 
272 directory then the filename is kept the same and the file is placed in that 
273 directory, if a name is specified then the file will be moved or copied to 
274 the new name. C<rm> removes files given to it as arguments, as many as you 
275 like.
276
277 =head3 Your home folder (theres no place like it)
278
279 When specifying paths there is another special character C<~>, which is short 
280 for your home directory. Your home directory is exactly what it sounds like, 
281 your place on the file system to keep your crap. If you use C<cd> without an 
282 argument it will take you to your home dir. Whats in your home dir? Well, any 
283 files you want to keep. Is that it? No, also kept in your homedir are so-called 
284 "dot files" since their filenames start with a C<.> so they don't normally show 
285 up in C<ls>, to view them use the B<a>ll option for C<ls>, C<-a>. These dot 
286 files store configuration information for various programs, as well as B<r>un 
287 B<c>ommands files with commands to be run on startup of various applications. 
288 You can edit these to customise your various preferences for applications, but 
289 consult the man pages first to make sure you enter sane values.
290
291 Also in your home folder is your web folder, usually called C<www> or 
292 C<public_html>, depending on the configuration of the system. To set up a 
293 personal web page all you have to do is place your html (or text or whatever) 
294 files in there and make sure they are world readable. Word Readable? What? 
295 Its a permission, subject of the next section.
296
297 =head3 File permissions, or how to keep people out of your crap.
298
299 In unix every file has an owner, these owners are the users, and an owning
300 group, which is some group that the owner is a member of. You can control who 
301 can read, write, and execute your files based on these categories: user, group, 
302 everyone. Collectively these permissions are known as the file's 
303 (or directory's) I<mode>. To view a file's mode use a long listing with 
304 C<ls -l> and look at the I<mode string>. Mode strings are 10 characters, the 
305 first character specifies if the file is a file with a C<-> or something 
306 special, like a directory C<d> or a character device like a terminal with C<c>. 
307 Following the file type are nine characters, they represent the 3 permissions 
308 for the 3 groups, the first three characters stand for B<r>ead, B<w>rite, and 
309 eB<x>ecute for the user, and repeat for the group and everyone. For example 
310 C<-rw-r-r> provides the owner read-write access and everyone else.
311
312 To B<ch>ange B<mod>es, B<own>er, or B<gr>ouB<p> of a file use the commands 
313 C<chmod>,C<chown>, and C<chgrp> (actually C<chown> can also change groups). 
314 We won't go into C<chown> since only the superuser (a user with more permissions 
315 than normal, for administrative purposes) can use it. To use C<chmod> to change 
316 modes first pass in a mode alteration followed by files you own. A mode 
317 alteration has the form C<w[+,-]p> where C<w> stands for who the mode change is 
318 for, B<u>ser owning the file, B<g>roup, B<o>thers, or B<a>ll groups, followed a 
319 C<+> to grant the permission or a C<-> to revoke it, and C<p> stands for the 
320 ability to change, B<r>ead, B<w>rite, or eB<x>ecute.
321
322 You may be wondering about the execute permission. This grants people the 
323 ability to run your files, if you have binaries or executable scripts to 
324 permission. Depending on the programs you might want to be careful with this. 
325 On directories, where executing makes little sense it is the permission to 
326 traverse or change into the directory.
327
328 =head3 Talking about more than one file at a time
329
330 Often its useful to talk about a group of files (like to tell C<rm> about them, 
331 or backup your website with C<cp>). The shell has a way to do this. Using a 
332 wildcard C<*> you can name all files that match a patern, for example C<*.mp3> 
333 would be all mp3s in a folder. Multiple wildcards can be used in a single name, 
334 but note they don't match C</>, that is they don't traverse directories. There is
335 also the C<?> wildcard which matches any one character.
336
337 Specific characters can also be matched using C<[..]> with the characters or a
338 range of characters (say C<[a-z]> to match all lowercase) to match. Note that
339 this only matches once, so for repeats you must repeat your bracket expression.
340
341 For more information on this matching/expansion, which is called 
342 I<file globbing> consult C<man 7 glob> (there will probably also be an entry
343 in section 3 of the system manual for glob. This is for a C library function
344 that actually works out the list of files from the glob expression).
345
346 If you want to specify a C<*>, C<?> or C<[> you must escape it with a C<\>,
347 and to get a literal C<\> you must escape that as well, using C<\\> in its
348 place. There are a few other characters that must be escaped: a space,
349 C<">, C<'>, and C<;> for reasons that may or may not be obvious now, but 
350 will be after the next section.
351
352 =for commentary
353
354 A section on searching for files (even if its just a blurb) would be
355 nice...
356
357 mgregson--
358 I'd recommend throwing in something about find.  It took me a while to figure
359 out all the nice little tricks you can do with find, but it's definitely a
360 worthwhile effort.
361
362 eg: find ~/src -type f -iname "*.java" -exec grep "/*TODO:*" {} \;
363
364 --mgregson
365
366 =cut
367
368 =head2 What the shell really gives you.. power.
369
370 Up until now we've only really covered features that you can find in your
371 familiar point and click environment. Going back to the language analogy
372 think of that as boring vocabulary work and whats about to be covered
373 grammar, rhyme, and meter work. This section discusses the features of the
374 shell that separate it from the gui, the programmable loops, variables that
375 affect program execution, and io redirection. This section describes the
376 machinary the shell provides to put words together to form ideas.
377
378 =head3 Every command you run is a process: how to run more than one.
379
380 Every command you start from the shell (well there are a few exceptions we'll
381 go in to in a bit) runs as a I<process>. In Unix processes represent separate
382 discrete running programs, for example you can have several processes which 
383 are all cp with different arguments (or the same arguments, but that is likely
384 to break and not advised). In playing around with what you've learned in the
385 last chapter you may have been frustrated by only being able to do one thing
386 at a time. The shell does not limit you to running one thing at a time, and
387 on the contrary gives you powerful tools for managing processes, both those 
388 started by you and those already running on the system.
389
390 For the purposes of I<job control>, processes can be viewed in two groups:
391 those under the control of your shell (your I<jobs>), and those not. We'll
392 first discuss the ways of starting your own jobs and interacting with them.
393
394 =head4 Your jobs and what to do about them
395
396 The first thing you're probably wondering is how to start more than one job.
397 To do this you first need to know the difference between a I<foreground>
398 process and a I<background> process. A foreground process is running attached
399 to your terminal, your command prompt goes away and is replaced by its output 
400 and any input goes to the program. With a program running in the background 
401 it doesn't recieve input (unless you have an io redirect, more on that later)
402 and output goes to your terminal, but you can still enter other commands.
403
404 Before we can get to fancier features you probably want to know how to stop
405 something in the foreground. To I<interrupt> or B<c>ancell the job in the
406 foreground press C<CTRL+C> (hereafter C<control> will be abreviated with C<^>
407 followed by a character. So C<CTRL+C> is C<^C> and so on and so forth). If you
408 want to pause the job instead of terminating it press C<^Z>. This stores the
409 process in a stopped state and gives you your command prompt back. You'll also
410 see a message that looks like
411
412  [1]+   Stopped         some command with args
413
414 The number in square brackets is the job number, C<+> means the state has
415 changed. This is followed by the new state and what job is being run. If you
416 want to bring your job back to the foreground type C<fg %1> and your job will
417 come back just as you left it. Not very interesting, but the next part is. If
418 you want to let your job finish running in the I<background> while you do
419 something else type C<bg %1> and your job will resume running, but you still
420 have a prompt to use. If you know you want a command to run in the background
421 and don't want to futz with C<^Z>ing it and then typing bg you can just put an
422 C<&> at the end of your command like so:
423
424  $cp ~/giant_file.tar.gz /mnt/usbdrive &
425
426 Note that the number 1 in C<%1> isn't special, its just the usual job number of
427 your first job. It will be different if you have more jobs running. To get a
428 list of your jobs type C<jobs>. This will have job numbers, states and what
429 command is running.
430
431 To terminate a job early or put one of your background in a "Stopped" state
432 (and often to communicate with it in other ways) unix provides I<signals>. A
433 signal is a numbered code sent to a process with a meaning defined by the
434 system. Commonly used signals are terminate, C<TERM>; kill, C<KILL>; and stop, 
435 C<STOP>. C<TERM> instructs a process to stop what its doing and quit, C<KILL>
436 ends it, and C<STOP> is equivalent to C<^Z>. Yes, C<^C> has a corresponding
437 signal: interrupt, C<INT>. To send signals to jobs use the C<kill> command.
438 By defaul C<kill> sends the C<TERM> signal, to specify other ones use C<-s>
439 followed by the signal name. You also need to tell C<kill> which job to send
440 the signal to.
441
442 =head4 Other processes
443
444 You may be wondering about the mention of processes not started by your shell.
445 These all have associated numbers, called a I<process id>. Your jobs also have
446 pids, and kill will take a pid instead of a job id. To see a listing of current
447 processes use the command C<ps>. This will give all sorts of information:
448 the pid, who started it, the attached terminal, whats running, the ram usage.
449 C<ps> gets more useful when you're using more than one terminal or performing
450 system administration.
451
452 =head3 Input, output, and the story of a plumber
453
454 As stated earlier processes running take input from standard input (your
455 keyboard) and send it to standard output (your terminal) or errors to standard
456 error (also your terminal). Sometimes this can be really inconvinent or down 
457 right aggravating. Fortunatly the shell has an answer, its called 
458 I<IO redirection>. This is the process of sending output somewhere other than
459 your terminal and getting it from somewhere other than your keyboard.
460
461 =head4 Simple redirection
462
463 Simple redirection sends program output to a file or brings input in from a
464 file. To connect input to a file use the C< < > character followed by a
465 file name like this:
466
467  $mysql < lots_of_sql_queries.sql
468
469 Output goes the other way, so naturally you use C<< > >> to send output to a file.
470 By default one C<< > >> overwrites a file, for output to append you must add a
471 second C<< > >>. Before going further, a word on I<file descriptors>. In unix when
472 a file is opened by the system the open file handle isn't attached directly to
473 the file on disk, but to a file descriptor, which is a number that the process
474 can use internaly. File descriptors are also used by interpreted scripts, which
475 when executed start an interpreter. Instead of passing the interpreter the
476 filename (which could have been changed to do nasty things if someone is up
477 to no good) the system passes the interpreter the file descriptor of an open
478 handle to that file, as these are process specific and much harder to muck
479 with. Normally you don't have to worry about file descriptors, but when
480 redirecting input and output its nice to be aware of 3 of them. These are fds
481 0,1, and 2, which correspond to standard in, standard out, and standard error
482 respectively.  The left sides of C<< < >>, C<< > >>, C<<< >> >>> all take an
483 implicit fd argument, 0 for the input operator and 1 for the output operators.
484 To redirect standard error add a 2 in front of your operators. You can also
485 redirect from one file descriptor to another using C<< i>&j >> to send output
486 on fd i to fd j.
487
488 File descriptors will be revisited when we discuss scripts, as you might have
489 a need for more than the 3 default file descriptors there.
490
491 You might be wondering if you can read from or write to other programs. Thats
492 the topic of the next section, just remember with simple redirection you can't
493 read from or send to programs.
494
495 =head4 You mentioned plumbing? I don't see any pipes
496
497 Actually, there are pipes in the shell, they are one of the most useful shell
498 features. A pipe or pipeline is a way to connect standard out of one program
499 to standard in of another. This is represented with the C<|> I<pipe> character.
500 To demonstrate its power say you have a command that generates a lot of output,
501 you don't really want to save it but you need to look at it, and it doesn't fit
502 on one screen. Using what you know above you do this:
503
504  $massive-output > output.txt
505  $less output.txt
506  $rm output.txt
507
508 Seems like a lot of work, since less by default reads from standard in. With
509 pipes this mess gets shortened to:
510
511  $massive-output | less
512
513 You can also chain pipelines using inbetween commands as filters, you can even
514 use many of the commands that normally take files in pipelines using the
515 special C<-> filename, consult the man pages for what you're using to get the
516 specifics, a lot of commands take input from standard input by default. If you
517 want to start the pipeline out with some text you enter you can put it in a
518 file or you can use C<cat -> to send standard in to standard out. When you are
519 done typing press C<^D> to send the End of File (EOF) character (Note not all
520 control characters send signals).
521
522 Chaining pipes was mentioned, this allows you to insert filters into the stream
523 we'll go over a few useful ones now, though for more in depth coverage check
524 the text editing tutorial.
525
526 =over 8
527
528 =item C<tee>
529
530 C<tee> creates a split in a pipe, saving the output to a file (or multiple
531 files) as well as passing it on standard out so the pipeline can continue.
532 Useful for saving state or putting a T in your pipeline and starting the
533 other branch with C<cat your_tee_savefile | rest_of_pipeline>.
534
535  $ command_pipeline | tee save_file | more_pipeline
536
537 =item C<grep>
538
539 C<grep>'s odd name comes from an antiquated unix editor and a common sequence
540 of commands used to search. These commands are B<g>lobally, B<r>egular 
541 B<e>xpression, B<p>rint, used to go through an entire file and print lines
542 matching a pattern. For details on C<grep>'s pattern format check the text
543 processing tutorial or the man page. C<grep> can be used on files but its 
544 mentioned here as a filter. When used in a pipe it will filter whats coming
545 in on the pipeline, outputting only what matches the pattern, for example:
546
547  $ps | grep mysql
548
549 will print information about every process with mysql somewhere in its
550 information (usually things run by the mysql user or mysql client processes).
551
552 =item C<sed>
553
554 C<sed> stands for B<s>tream B<ed>itor, and provides powerful facilities for
555 editing data as it comes in through a pipeline. C<sed> can also automate various
556 other editing tasks. More information on C<sed> can be found in the editing
557 tutorial.
558
559 =item C<sort>
560
561 C<sort> does exactly what you think it does, takes input, outputs a sorted
562 version. The various options in the man page control different ways of sorting,
563 but its not worth mentioning them here, as I'm sure you'll look it up when you
564 actually need it instead of reading it now and forgetting it.
565
566 =item C<uniq>
567
568 C<uniq> takes input and outputs only the B<uniq>ue lines. A useful option is
569 C<-c> which gives you a count of repitions.
570
571 =item C<wc>
572
573 C<wc> is a B<w>ord B<c>ounting program. It takes input and outputs the number
574 of lines, words, and characters in the input. It will also take a file or many
575 files and give you by file output as well as totals. You might write a version
576 someday...
577
578 =back
579
580 =head3 Variables and the Environment (no you don't have to go green)
581
582 At this point you may have guessed that the shell is infact an interactive
583 programming language designed specifically for gluing other programs together
584 and administering systems. If you did, you're right. If not, well it is, and
585 like most programming languages it has support for variables. Variables in the
586 shell come in two forms: locally scoped variables and I<environment> variables.
587 Locally scoped variables are visible only to one command (commands may start
588 multiple programs, see other parts of this chapter for how) while environment
589 variables are visible to everything that runs as a child of your shell (unless
590 otherwise specified, but we'll get to that).
591
592 To set local variables just use C<=> in a statement, like:
593
594  $var="stuff";
595
596 and to get values append a C<$> to the name and the shell will substitute it:
597
598  $echo $var
599
600 (echo just prints out what you pass to it).
601
602 Environment variables are global to your shell and allow you to customize
603 various shell options and inform programs you start of your preferences for
604 things like your pager and your prefered text editor. To get a full rundown
605 of the available vars check out the manpage for C<environ(7)> (if you haven't
606 read at least a bit of C<man man> yet the number is a manual section, and to
607 specify it place it before the name of the page: C<man 7 environ>). To set new
608 ones or modify your current ones use C<export> followed by your assignment
609 statement, or just the variable name if you have it set already. If you're
610 curious about what variables are already set just run C<export> without
611 arguments.
612
613 If you want environment variables to remain set in new sessions edit your
614 F<.bash_profile> or F<.profile> file and add new lines with your export
615 commands. For more on these files see the customizing your shell section.
616
617 =head3 Scripting the shell
618
619 Since the shell is really just an interactive programming language an obvious
620 question is "does it have a non-interactive mode?". The answer is yes. This is
621 called I<shell scripting> and is a useful way to automate repetitive tasks and
622 add desired functionality. Since the interactive shell and the scripted shell
623 are the same thing, features discussed here can be used at the prompt, though
624 they may not be useful.
625
626 Shell scripts consist of a series of shell commands on separate lines or
627 separated by semicolons. To create one open an editor on a new file (call it
628 whatever you like, by convention they have the C<.sh> extension) and enter
629 the sequence of commands you wish to be able to run over and over again. Save
630 the file and make sure you have permission to execute it. Then at the prompt
631 type C<./your_file_name> to run it. 
632
633 Scripts can also take arguments, these appear in variables C<$1> to C<$9>,
634 (if you need more than nine place the numbers in braces). There are also some 
635 useful special variables: C<$?> is the exit status of the last command run,
636 an indicator of error conditions; C<$$> is the process id of the script, and
637 C<$0> is the name of the script, which provide relevant information for error
638 messages as well as the change of behavior based on script name or process id
639 (the first one is sometimes used for startup/shutdown scripts, the second one
640 is insane).
641
642
643 =head3 Its a programming language? Wheres while and friends?
644
645 Yes, the shell is an interactive programming language, and yes there are loops
646 and conditional expressions. If you've ever used an imperitive programming
647 language (like Java or VB or Perl) these first few should be familiar. These
648 are going to be quick commentaries, for more info you can read the shell man
649 page.
650
651 =over
652
653 =item C<if>
654
655 If works just like you'd expect, except there are also a myriad of useful file
656 test options to query the properties of files and file descriptors.
657
658  if [ -e "filename" ]; then 
659      echo "filename exists";
660  fi
661
662  if [ "$3" = "start" ]; then
663      echo "starting";
664  elif [ "$3" = "stop" ]; then
665      echo "stopping";
666  else
667      echo "option 3 invalid";
668  fi
669
670 =item C<while>,C<until>
671
672 While loops while a condition is true, until loops until a condition is true. 
673 These are the same conditions used in if.
674
675  while [ -e "lockfile" ]; do
676      echo "waiting for lock to be released";
677      sleep 5;
678  done;
679
680  X=0
681  until [ $X = 20 ]; do
682      echo "zomgwtf";
683      X=$((X+1)) # arithmatic expression, read the man page. You probably
684                 # want to use a real programming language for heavy iteration
685  done;
686
687 =item C<for x in>
688
689 While bash has a c style for loop, don't use it. You probably want a real
690 programming language at that point. The useful for loop iterates through a
691 list for you, setting x (or whatever other variable name you use) to the values
692 one at a time. You can use a plain list, a file glob, or any command in
693 backticks (which evaluates the command and substitutes the value).
694
695  # Backup git repositories in /backup/repos
696  for d in `ls -d /backup/repos`; do
697      cd $d;
698      git pull;
699  done;
700
701 =back
702
703 =head3 Customizing your shell
704
705 Through this document we've been talking about "the shell". The fact is there
706 are many, many, shells all with the standard features discussed here (and some
707 without) as well as a variety of extensions and unique features.
708
709 The shell used as a reference when writing this guide and a common default is
710 C<bash>, B<B>ourne B<A>gain B<Sh>ell, also popular are C<ksh> (B<K>orn 
711 B<Sh>ell), C<csh> (B<C> B<Sh>ell), C<tcsh> (an enhancement of C<csh>), and
712 C<zsh> (the B<Z> B<Sh>ell, an addition of new features to a C<ksh> and C<bash>
713 featrues). Feel free to experiment, you can start a new shell by invoking it as
714 a command or using C<chsh> and logging out and in again.
715
716 To set shell options and environment variables you can edit the various F<rc>
717 and F<profile> files associated with your shell, check the man page for details
718 on which files to edit.
719
720 In these files you can also start background jobs if you'd like, though it is
721 often more useful to have automated tasks. Many systems have a C<cron> program
722 installed which can be used to run programs even when you aren't around, to
723 add these edit a file called a F<crontab> using the progrogram with the same
724 name to do so. Check the associated man page for syntax in the file and what
725 you can and cannot run in it.
726
727 =head2 About the Authors (when they wrote this)
728
729 This document is maintained and copyright The University of Waterloo Computer
730 Science Club 2008 and is released under the terms of the Artistic Liscence
731 version 2.0 available at L<http://www.perlfoundation.org/artistic_license_2_0>.
732
733 =head3 Edgar Bering (ebering@csclub.uwaterloo.ca)
734
735 A student heading into his second year Edgar served as club secretary W08 and
736 plans on running for executive most of the rest of the time he's around.