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