Antediluvian Unix

This is a primer on the basics of everyday unix concepts. I gave this to my local Linux user group sometime around 2001. It seemed helpful, and I've gotten comments from other new unix users since then that it's still helpful.

Transcript

1. Antediluvian Unix a guide to unix fundamentals revision 1
2. Why is UNIX so hard?
3. Why is UNIX so hard? - UNIX is made of tiny little pieces, all alike.
4. Why is UNIX so hard? - UNIX is made of tiny little pieces, all alike. - They can be put together in many ways.
5. Why is UNIX so hard? - UNIX is made of tiny little pieces, all alike. - They can be put together in many ways. - The pieces have manuals, but UNIX doesn’t.
6. Why is UNIX so hard? - UNIX is made of tiny little pieces, all alike. - They can be put together in many ways. - The pieces have manuals, but UNIX doesn’t. - The Mysteries of UNIX were handed down in an oral tradition.
7. Why is UNIX so hard? - UNIX is made of tiny little pieces, all alike. - They can be put together in many ways. - The pieces have manuals, but UNIX doesn’t. - The Mysteries of UNIX were handed down in an oral tradition. - Then the GNU/Linux flood happened.
8. The Deluge
9. The Deluge - Users adopted Linux as their first unix, learning everything from HOWTOs.
10. The Deluge - Users adopted Linux as their first unix, learning everything from HOWTOs. - The GNU system combined toolkit pieces.
11. The Deluge - Users adopted Linux as their first unix, learning everything from HOWTOs. - The GNU system combined toolkit pieces. - Distributions with X11 out of the box further obfuscated the shell.
13. We’re going to talk about antediluvian UNIX.
15. ...but we’re going to use modern tools.
16. ...but we’re going to use modern tools. Because being a fundamentalist does not mean being a relic.
17. UNIX at Rest the unix filesystem
18. The Time Before UNIX
19. The Time Before UNIX - Every file had a structure: a list of similar records.
20. The Age of UNIX
21. The Age of UNIX - Forcing a record structure on every file was a hassle.
22. The Age of UNIX - Forcing a record structure on every file was a hassle. - Plain text was easier to read and edit without special tools.
23. The Age of UNIX - Forcing a record structure on every file was a hassle. - Plain text was easier to read and edit without special tools. - So records were stored in the natural plain text way: columns and lines.
24. The Age of UNIX - Forcing a record structure on every file was a hassle. - Plain text was easier to read and edit without special tools. - So records were stored in the natural plain text way: columns and lines. - Every file is just a bytestream.
25. The Flat File 127.0.0.1 localhost 66.92.232.136 cheshirecat 66.92.232.135 redking 192.168.200.1 airport
26. The Flat File 127.0.0.1 localhost 66.92.232.136 cheshirecat 66.92.232.135 redking 192.168.200.1 airport FS = space RS = newline
27. The Flat File root:x:0:0::/root:/bin/sh rjbs:x:101:100:RJBS:/home/rjbs:/bin/zsh
28. The Flat File root:x:0:0::/root:/bin/sh rjbs:x:101:100:RJBS:/home/rjbs:/bin/zsh FS = colon RS = newline
29. Special Files
30. Special Files - Files that contain data are plain files.
31. Special Files - Files that contain data are plain files. - Other (special) files perform system magic.
32. Special Files - Files that contain data are plain files. - Other (special) files perform system magic. - directories
33. Special Files - Files that contain data are plain files. - Other (special) files perform system magic. - directories - symbolic links
34. Special Files - Files that contain data are plain files. - Other (special) files perform system magic. - directories - symbolic links - named pipes
35. Special Files - Files that contain data are plain files. - Other (special) files perform system magic. - directories - symbolic links - named pipes - sockets
36. Special Files - Files that contain data are plain files. - Other (special) files perform system magic. - directories - symbolic links - named pipes - sockets - devices
37. Permissions
38. Permissions - Every file has associated permissions.
39. Permissions - Every file has associated permissions. - Permissions govern reading, writing, and execution.
40. Permissions - Every file has associated permissions. - Permissions govern reading, writing, and execution. - And then there are the special permissions: s?id and sticky.
41. Permissions - Every file has associated permissions. - Permissions govern reading, writing, and execution. - And then there are the special permissions: s?id and sticky. ----------
42. Magic Numbers
43. Magic Numbers - UNIX supports many executable file types.
44. Magic Numbers - UNIX supports many executable file types. - Roughly 65,535, at the minimum.
45. Magic Numbers - UNIX supports many executable file types. - Roughly 65,535, at the minimum. - Magic numbers identify the file type.
46. Magic Numbers - UNIX supports many executable file types. - Roughly 65,535, at the minimum. - Magic numbers identify the file type. - They’re the first two bytes of the file.
47. The Magic Magic Number
48. The Magic Magic Number - One magic number, 0x2321, is common in modern unices.
49. The Magic Magic Number - One magic number, 0x2321, is common in modern unices. - In ASCII, it’s #!
50. The Magic Magic Number - One magic number, 0x2321, is common in modern unices. - In ASCII, it’s #! - In English, it’s “shebang!”
51. The Magic Magic Number - One magic number, 0x2321, is common in modern unices. - In ASCII, it’s #! - In English, it’s “shebang!” - The kernel will run the program named after #! with the given args, plus the filename.
52. #! in Action
53. #! in Action #!/bin/sh echo Good morning, $USER! ~/bin/hello
54. #! in Action #!/bin/sh echo Good morning, $USER! ~/bin/hello knave!rjbs% hello
55. #! in Action #!/bin/sh echo Good morning, $USER! ~/bin/hello execve( ”/bin/sh”, “/home/rjbs/hello” ); knave!rjbs% hello
56. #! in Action
57. #!/usr/bin/awk -f BEGIN { FS=”:”; } {} ($7 != “”) && ($5 !=””) { {print “Hello, “ $1 “!”;} END { print “Buh-bye!” } ~/bin/hi_all #! in Action
58. #!/usr/bin/awk -f BEGIN { FS=”:”; } {} ($7 != “”) && ($5 !=””) { {print “Hello, “ $1 “!”;} END { print “Buh-bye!” } ~/bin/hi_all #! in Action
59. #!/usr/bin/awk -f BEGIN { FS=”:”; } {} ($7 != “”) && ($5 !=””) { {print “Hello, “ $1 “!”;} END { print “Buh-bye!” } ~/bin/hi_all #! in Action
60. #!/usr/bin/awk -f BEGIN { FS=”:”; } {} ($7 != “”) && ($5 !=””) { {print “Hello, “ $1 “!”;} END { print “Buh-bye!” } ~/bin/hi_all #! in Action knave!rjbs% hi_all /etc/passwd
61. Hello, sync! Hello, shutdown! Hello, halt! Hello, operator! Hello, gdm! Hello, samael! Hello, rjbs! Hello, calliope! Hello, solios! Hello, photon! Buh-bye!
62. UNIX in Motion unix program execution
63. The Process Tree
64. The Process Tree - Every running process is the child of the process that ran it (except init).
65. The Process Tree - Every running process is the child of the process that ran it (except init). - A child can’t live without its parent.
66. The Process Tree - Every running process is the child of the process that ran it (except init). - A child can’t live without its parent. - A child starts life with a copy of its parent’s environment.
67. Environment
68. Environment - An environment is a set of data communicated from parent to child.
69. Environment - An environment is a set of data communicated from parent to child. - Parents teach children, but children can never teach parents.
70. Environment - An environment is a set of data communicated from parent to child. - Parents teach children, but children can never teach parents. - This is important.
71. Environment - An environment is a set of data communicated from parent to child. - Parents teach children, but children can never teach parents. - This is important. - Really important.
72. MAIL=/var/spoołmaiłrjbs MAILCHECK=60 IRCSERVER=us.slashnet.org IRCNICK=rjbs LESS=-M init -+ |-zsh
73. knave!rjbs% IRCNICK=rsignes irssi MAIL=/var/spoołmaiłrjbs MAILCHECK=60 IRCSERVER=us.slashnet.org IRCNICK=rjbs LESS=-M init -+ |-zsh
74. knave!rjbs% IRCNICK=rsignes irssi MAIL=/var/spoołmaiłrjbs MAILCHECK=60 IRCSERVER=us.slashnet.org LESS=-M init -+ |-zsh
75. knave!rjbs% IRCNICK=rsignes irssi MAIL=/var/spoołmaiłrjbs MAILCHECK=60 IRCSERVER=us.slashnet.org LESS=-M IRCNICK=rsignes init -+ |-zsh
76. knave!rjbs% IRCNICK=rsignes irssi MAIL=/var/spoołmaiłrjbs MAILCHECK=60 IRCSERVER=us.slashnet.org LESS=-M IRCNICK=rsignes init -+ |-zsh -irssi
77. MAIL=/var/spoołmaiłrjbs MAILCHECK=60 IRCSERVER=us.slashnet.org LESS=-M IRCNICK=rsignes init -+ |-zsh -irssi
78. MAIL=/var/spoołmaiłrjbs MAILCHECK=60 IRCSERVER=us.slashnet.org LESS=-M IRCNICK=rsignes init -+ |-zsh
79. MAIL=/var/spoołmaiłrjbs MAILCHECK=60 IRCSERVER=us.slashnet.org LESS=-M init -+ |-zsh
80. MAIL=/var/spoołmaiłrjbs MAILCHECK=60 IRCSERVER=us.slashnet.org IRCNICK=rjbs LESS=-M init -+ |-zsh
81. Signals
82. Signals - Processes mind their own business and try to run to completion.
83. Signals - Processes mind their own business and try to run to completion. - But they can be sent signals to make them do unusual things.
84. Signals - Processes mind their own business and try to run to completion. - But they can be sent signals to make them do unusual things. - Mostly, “stop running.”
85. Some Common Signals
86. Some Common Signals SIGHUP
87. Some Common Signals SIGHUP SIGINT
88. Some Common Signals SIGHUP SIGQUIT SIGINT
89. Some Common Signals SIGHUP SIGILL SIGQUIT SIGINT
90. Some Common Signals SIGHUP SIGILL SIGTRAP SIGQUIT SIGINT
91. Some Common Signals SIGHUP SIGILL SIGTRAP SIGABRT SIGQUIT SIGINT
92. Some Common Signals SIGHUP SIGILL SIGBUS SIGTRAP SIGABRT SIGQUIT SIGINT
93. Some Common Signals SIGHUP SIGILL SIGBUS SIGTRAP SIGABRT SIGKILL SIGQUIT SIGINT
94. Some Common Signals SIGHUP SIGILL SIGSEGV SIGBUS SIGTRAP SIGABRT SIGKILL SIGQUIT SIGINT
95. Some Common Signals SIGHUP SIGILL SIGSEGV SIGBUS SIGTRAP SIGABRT SIGKILL SIGQUIT SIGINT SIGTERM
96. Some Common Signals SIGHUP SIGSTOP SIGILL SIGSEGV SIGBUS SIGTRAP SIGABRT SIGKILL SIGQUIT SIGINT SIGTERM
97. Some Common Signals SIGHUP SIGCONT SIGSTOP SIGILL SIGSEGV SIGBUS SIGTRAP SIGABRT SIGKILL SIGQUIT SIGINT SIGTERM
98. Some Common Signals SIGHUP SIGCONT SIGSTOP SIGILL SIGSEGV SIGBUS SIGTRAP SIGABRT SIGKILL SIGQUIT SIGINT SIGTERM SIGPWR
99. The Time Before UNIX
100. The Time Before UNIX - Your computer ran one program.
101. The Time Before UNIX - Your computer ran one program. - When that program was done, it ran the next.
102. The Time Before UNIX - Your computer ran one program. - When that program was done, it ran the next. - Lather, rinse, repeat.
103. The Time Before UNIX - Your computer ran one program. - When that program was done, it ran the next. - Lather, rinse, repeat. - Batch processing.
104. The Age of UNIX
105. The Age of UNIX - Many programs run at once.
106. The Age of UNIX - Many programs run at once. - Interactive programs became possible.
107. The Age of UNIX - Many programs run at once. - Interactive programs became possible. - ...but batch processing is not dead.
108. Job Control
109. Job Control - A system for handling batch processing in UNIX.
110. Job Control - A system for handling batch processing in UNIX. - Jobs can be
111. Job Control - A system for handling batch processing in UNIX. - Jobs can be - paused
112. Job Control - A system for handling batch processing in UNIX. - Jobs can be - paused - run in the background
113. Job Control - A system for handling batch processing in UNIX. - Jobs can be - paused - run in the background - brought to the foreground
114. Job Control knave!rjbs%
115. Job Control knave!rjbs% jobs [1]+ Running make bzImage& [2] Running backup& [3]- Suspended wget -rnp http... [4] Running pdflatex thesis.tex knave!rjbs%
116. Job Control knave!rjbs% jobs [1]+ Running make bzImage& [2] Running backup& [3]- Suspended wget -rnp http... [4] Running pdflatex thesis.tex knave!rjbs% mutt
117. Job Control knave!rjbs% jobs [1]+ Running make bzImage& [2] Running backup& [3]- Suspended wget -rnp http... [4] Running pdflatex thesis.tex knave!rjbs% mutt [2] Done backup& [4] Done pdflatex thesis.tex
118. #!/bin/sh for i in 1 2 3 4 5 6 7 8 9 10 do sleep $i done ~/bin/waiter Job Control in Action How long does this take to run?
119. ~/bin/waiter Job Control in Action How long does this take to run? #!/bin/sh for i in 1 2 3 4 5 6 7 8 9 10 do (sleep $i)& done wait
120. Job Control
121. Job Control - Ctrl-Z
122. Job Control - Ctrl-Z - bg and fg
123. Job Control - Ctrl-Z - bg and fg - &
124. Job Control - Ctrl-Z - bg and fg - & - jobs
125. Job Control - Ctrl-Z - bg and fg - & - jobs - wait
126. Bytestreams
127. Bytestreams - Files, you remember, are just bytestreams.
128. Bytestreams - Files, you remember, are just bytestreams. - A bytestream is list of bytes, in order.
129. Bytestreams - Files, you remember, are just bytestreams. - A bytestream is list of bytes, in order. - But it’s a stream: it flows
130. Bytestreams - Files, you remember, are just bytestreams. - A bytestream is list of bytes, in order. - But it’s a stream: it flows - in and out of programs
131. Bytestreams - Files, you remember, are just bytestreams. - A bytestream is list of bytes, in order. - But it’s a stream: it flows - in and out of programs - through pipes
132. Bytestreams
133. Bytestreams - Programs read and write from bytestreams all the time.
134. Bytestreams - Programs read and write from bytestreams all the time. - But a UNIX program’s favorite bytestreams are the standard IO streams.
135. Bytestreams - Programs read and write from bytestreams all the time. - But a UNIX program’s favorite bytestreams are the standard IO streams. - stdin - standard input
136. Bytestreams - Programs read and write from bytestreams all the time. - But a UNIX program’s favorite bytestreams are the standard IO streams. - stdin - standard input - stdout - standard output (1)
137. Bytestreams - Programs read and write from bytestreams all the time. - But a UNIX program’s favorite bytestreams are the standard IO streams. - stdin - standard input - stdout - standard output (1) - stderr - standard err (2)
138. Standard I/O
139. Standard I/O - The standard I/O streams are usually connected to the terminal.
140. Standard I/O - The standard I/O streams are usually connected to the terminal. - But you can redirect them.
141. Standard I/O - The standard I/O streams are usually connected to the terminal. - But you can redirect them. - Understanding I/O redirection is fundamental to using UNIX effectively.
142. #!/bin/sh alias > .bash_tmp_1 cat .bash_alias .bash_tmp1 \ > .bash_tmp_2 sort < .bash_tmp_2 > .bash_tmp_1 uniq < .bash_tmp_1> .bash_tmp_2 mv .bash_tmp_2 .bash_alias rm .bash_tmp_1 ~/bin/savalias Redirection in Action
143. #!/bin/sh alias \ | cat - .bash_alias \ | sort | uniq > .bash_alias ~/bin/savalias Redirection in Action
144. #!/bin/sh netstat -n \ | grep ESTABLISHED \ | cut -c 45-65 \ | awk ‘BEGIN{FS=”:”}{print $1}’ \ | sort -n \ | uniq ~/bin/connected Redirection in Action
145. Redirection
146. Redirection - > - >> - < - | - `` or $()
147. Arguments
148. Arguments - Programs are passed a list of arguments, given on the command line.
149. Arguments - Programs are passed a list of arguments, given on the command line. - These are usually switches that change how the program will work.
150. Arguments - Programs are passed a list of arguments, given on the command line. - These are usually switches that change how the program will work. - In lieu of stdio, arguments may name files on which to operate.
151. Return Values
152. Return Values - When a job finishes, its status is reported by a single integer.
153. Return Values - When a job finishes, its status is reported by a single integer. - This “return value” indicates success, failure, or other information.
154. Process stdin stdout stderr arguments return value environment other processes signals
155. The UNIX Toolkit elementary programs
156. The Toolkit
157. The Toolkit - Little utilities.
158. The Toolkit - Little utilities. - Found almost everywhere.
159. The Toolkit - Little utilities. - Found almost everywhere. - Work the same almost everywhere.
160. Some Toolkit Programs
161. Some Toolkit Programs cd
162. Some Toolkit Programs cd ls
163. Some Toolkit Programs cd cp ls
164. Some Toolkit Programs cd mv cp ls
165. Some Toolkit Programs cd mv rm cp ls
166. Some Toolkit Programs cd mv rm mkdir cp ls
167. Some Toolkit Programs cd mv chmod rm mkdir cp ls
168. Some Toolkit Programs cd mv chmod rm mkdir chown cp ls
169. Some Toolkit Programs cd mv chmod rm mkdir chown cp ls sort
170. Some Toolkit Programs cd mv chmod rm mkdir chown cp ls sort uniq
171. Some Toolkit Programs cd mv chmod rm mkdir chown cp ls sort cat uniq
172. Some Toolkit Programs cd mv chmod rm mkdir chown cp ls sort test cat uniq
173. Some Toolkit Programs cd mv chmod rm mkdir chown cp ls sort test basename cat uniq
174. Some Toolkit Programs cd mv chmod rm mkdir chown cp ls sort test basename cut cat uniq
175. Some Toolkit Programs cd mv chmod rm mkdir chown cp ls sort test tr basename cut cat uniq
176. Some Toolkit Programs cd mv chmod rm mkdir chown cp ls sort test tr basename cut grep cat uniq
177. Some Toolkit Programs cd mv chmod rm mkdir chown cp ls sort test tr basename cut grep cat uniq seq
178. Some Toolkit Programs cd mv chmod rm mkdir chown cp ls sort test tr basename cut grep cat uniq seq yes
179. Some Toolkit Programs cd mv chmod rm mkdir chown cp ls sort test tr basename cut grep cat uniq seq true yes
180. Some Toolkit Programs cd mv chmod rm mkdir chown cp ls sort test tr basename cut grep cat uniq seq false true yes
181. Some Toolkit Programs cd mv chmod rm mkdir chown cp ls sort test tr basename cut grep cat uniq seq false true yes
182. #!/bin/sh cat /etc/passwd /sbin/armageddon The Toolkit in Action
183. #!/bin/sh cat /etc/passwd \ | grep :100: /sbin/armageddon The Toolkit in Action
184. #!/bin/sh cat /etc/passwd \ | grep :100: \ | cut -d: -f6 /sbin/armageddon The Toolkit in Action
185. #!/bin/sh rm -R $(cat /etc/passwd \ | grep :100: \ | cut -d: -f6) /sbin/armageddon The Toolkit in Action
186. #!/bin/sh yes | rm -R $(cat /etc/passwd \ | grep :100: \ | cut -d: -f6) \ echo Users obliterated! /sbin/armageddon The Toolkit in Action
187. The Shell
188. The Shell - Just another piece of the toolkit.
189. The Shell - Just another piece of the toolkit. - But the first among equals.
190. The Shell - Just another piece of the toolkit. - But the first among equals. - Provides flow control for processes.
191. The Shell - Just another piece of the toolkit. - But the first among equals. - Provides flow control for processes. - Also, built-in utilities.
192. The Shell - Just another piece of the toolkit. - But the first among equals. - Provides flow control for processes. - Also, built-in utilities. - ...but most of these are extraneous.
193. Flow Control
194. Flow Control - Controls:
195. Flow Control - Controls: - whether a process will run
196. Flow Control - Controls: - whether a process will run - when a process will run
197. Flow Control - Controls: - whether a process will run - when a process will run - process iteration over a list of data
198. #!/bin/sh if [ $UID = 0 ]; then echo You’re root! else echo You’re a luser! fi Flow Control
199. #!/bin/sh if [ $UID = 0 ]; then echo You’re root! else echo You’re a luser! fi Flow Control So, how does sh compare $UID and zero?
200. Process stdin stdout stderr arguments return value environment other processes signals
201. #!/bin/sh if test $UID = 0; then echo You’re root! else echo You’re a luser! fi if
202. #!/bin/sh if cp $@ $HOME; then echo Everything’s fine! else echo WE’RE ALL GONNA DIE! fi if
203. #!/bin/sh if [ $UID = 0 ]; then echo You’re root! else echo You’re a luser! fi Flow Control
204. #!/bin/sh for dir in ~/code/*; do cd $dir; make done for ~/bin/makeall
205. #!/bin/sh for dir in ~/code/*; do \ if [ -d $dir -a -r $dir/Makefile ]; then cd $dir; make fi done for and if ~/bin/makeall
206. #!/bin/sh for dir in ~/code/*; do \ if [ -d $dir -a -r $dir/Makefile ]; then (cd $dir; make)& fi done wait for, if, and job control ~/bin/makeall
207. #!/bin/sh echo $$ > ~/unique_pid while [ $$ = $(cat ~/unique_pid) ] do sleep 1 done echo Replaced by $(cat ~/unique_pid) while ~/bin/unique
208. #!/bin/sh echo $$ > ~/unique_pid until [ $$ != $(cat ~/unique_pid) ] do sleep 1 done echo Replaced by $(cat ~/unique_pid) until ~/bin/unique
209. #!/bin/sh if [ -r ~/unique_pid ]; then kill $(cat ~/unique_pid) rm ~/unique_pid fi echo $$ > ~/unique_pid while true do rm -R $1/* > /dev/null done while and if ~/bin/rmcont
210. #!/bin/sh select user in $(who|cut -f1 -d” “|uniq) do if [ $user ]; then talk $user; fi break done select ~/bin/chat
211. #!/bin/sh select user in $(who|cut -f1 -d” “|uniq) do if [ $user ]; then talk $user; fi break done select ~/bin/chat 1) rjbs 2) calliope #?
212. #!/bin/sh case “$1” in *.tgz|*.tar.gz) tar zxvf $1;; *.tar.bz2) tar jxvf $1;; *.gz) gunzip $1;; *.tar) tar xvf $1;; *.zip) unzip $1;; *.shar.gz) cat $1 | gunzip | unshar > \ $(basename $1 .shar.gz) ;; *) echo Unknown archive type! esac case ~/bin/unarc
213. Redefining Your UNIX customizing the interactive experience
214. Why script?
215. Why script? - Any shell command can be entered directly at the command line.
216. Why script? - Any shell command can be entered directly at the command line. - So why script?
217. Why script? - Any shell command can be entered directly at the command line. - So why script? - Scripting lets you remember useful recipes.
218. Why script? - Any shell command can be entered directly at the command line. - So why script? - Scripting lets you remember useful recipes. - And abstract them.
219. My Favorite Scripts
220. My Favorite Scripts - ...are incredibly simple.
221. My Favorite Scripts - ...are incredibly simple. - They just eliminate some keystrokes.
222. My Favorite Scripts - ...are incredibly simple. - They just eliminate some keystrokes. #!/bin/sh screen -x $@ ~/bin/sx
223. My Favorite Scripts - ...are incredibly simple. - They just eliminate some keystrokes. #!/bin/sh screen -x $@ ~/bin/sx #!/bin/sh module-starter --author=”Ricardo Signes \ --email=”rjbs@cpan.org” $@ ~/bin/n2pm
224. Functions
225. Functions - These don’t need to be scripts.
226. Functions - These don’t need to be scripts. - You can do this with functions.
227. Functions - These don’t need to be scripts. - You can do this with functions. knave!rjbs% sx() { screen -x $@ }
228. Functions - These don’t need to be scripts. - You can do this with functions. knave!rjbs% cs() { cp $2 $2.bak; cp $1 $2 } knave!rjbs% sx() { screen -x $@ }
229. Functions - These don’t need to be scripts. - You can do this with functions. knave!rjbs% cs() { cp $2 $2.bak; cp $1 $2 } knave!rjbs% ch() { awk ‘FNR==1{for(i=1;i<=NF;i++)print $i}{next}’ $@ } knave!rjbs% sx() { screen -x $@ }
231. Aliases
232. Aliases - Aliases can do much of what functions can.
233. Aliases - Aliases can do much of what functions can. - Quoting makes them hard to write.
234. Aliases - Aliases can do much of what functions can. - Quoting makes them hard to write. - Single-lining makes them harder.
235. Aliases - Aliases can do much of what functions can. - Quoting makes them hard to write. - Single-lining makes them harder. - Those can be worked around, but why bother?
236. Aliases
237. Aliases - There are three reasons to bother:
238. Aliases - There are three reasons to bother: - better recursion protection
239. Aliases - There are three reasons to bother: - better recursion protection - non-command aliases (the space hack)
240. Aliases - There are three reasons to bother: - better recursion protection - non-command aliases (the space hack) - higher precedence
241. Aliases - There are three reasons to bother: - better recursion protection - non-command aliases (the space hack) - higher precedence - I still don’t bother.
242. Functions
243. Functions - More reasons to use functions:
244. Functions - More reasons to use functions: - they’re already in memory
245. Functions - More reasons to use functions: - they’re already in memory - they run in the current process
246. Functions - More reasons to use functions: - they’re already in memory - they run in the current process - they produce scope
247. Scope
248. Scope - Scope is the place where something is visible.
249. Scope - Scope is the place where something is visible. - Using scope wisely makes life easy.
250. Scope - Scope is the place where something is visible. - Using scope wisely makes life easy. - The file hierarchy is a kind of scope.
251. Scope - Scope is the place where something is visible. - Using scope wisely makes life easy. - The file hierarchy is a kind of scope. - So is the process environment.
252. Scope cvsroot() { if [ “$1” != “” ]; then if [ -f $CVSROOT_DIR/$1 ]; then CVSROOT=$(cat $CVSROOT_DIR/$1) else echo cvsroot: $CVSROOT_DIR/$1 is invalid fi else echo cvsroot: currently $CVSROOT fi } Functions can alter the running shell. (It’s in scope.)
253. Scope mown() { local filename = $1 local owner = $(ls -l $1|cut -c21-29) mail $owner } Function variables can be made local (scope-limited).
254. Scope #!/bin/sh hypotenuses() { pythagoras() { echo $(dc -e “$1 2 ^ $2 2 ^ v f”) } for $side in $*; do pythagoras $side; done } Nested functions are scoped to the enclosing function. The pythagoras() function is not visible outside of hypotenuses().
255. Scope #!/bin/sh hypotenuse() { echo $(dc -e “$1 2 ^ $2 2 ^ v f”) } for side do hypotenuse $(dc -e “$side 2 / f”) Functions are scoped to their enclosing script. The special-purpose hypotenuse() function will go away when the script is done running.
256. Scope for func in ~/.bash/functions/*; do . $i done This is how I load my functions. (it’s in my profile)
257. Scripts
258. - When are scripts useful? Scripts
259. - When are scripts useful? - programs not run under a login Scripts
260. - When are scripts useful? - programs not run under a login - programs too large to leave in memory Scripts
261. - When are scripts useful? - programs not run under a login - programs too large to leave in memory - rarely-used programs Scripts
262. - When are scripts useful? - programs not run under a login - programs too large to leave in memory - rarely-used programs - In almost no case do I write sh scripts. Scripts
263. Scripts
264. Scripts - ...but I write plenty of other scripts.
265. Scripts - ...but I write plenty of other scripts. - Shell scripts lose utility because I’m always in the shell.
266. Scripts - ...but I write plenty of other scripts. - Shell scripts lose utility because I’m always in the shell. - But I’m not limited to shell scripts! I have the shebang!
267. #!/usr/bin/whatever
268. #!/usr/bin/whatever - Almost any interpreted data file can be run.
269. #!/usr/bin/whatever - Almost any interpreted data file can be run. - It needs a shebang and +x permissions.
270. #!/usr/bin/whatever - Almost any interpreted data file can be run. - It needs a shebang and +x permissions. - The key is knowing the right tool.
271. #!/usr/bin/awk -f BEGIN { FS=”:”; } {} ($7 != “”) && ($5 !=””) { {print “Hello, “ $1 “!”;} END { print “Buh-bye!” } ~/bin/hi_all #! in Action
272. #!/usr/bin/awk -f BEGIN { FS=”:” } ($7 != “”) && ($5 !=””) {print “Hello, “ $1 “!”;} {next} END { print “Buh-bye!” } ~/bin/hi_all #!/usr/bin/whatever
273. #!/usr/bin/whatever #!/usr/bin/make -f RSYNC_SW=”--delete -ave ssh” default: web gnupg logs mirrors: ifarchive minicpan all: default mirrors web: rsync ${RSYNC_SW} ${HOME}/public_htmł cheshire:~/public_htmł gnupg: rsync ${RSYNC_SW} cheshire:~/.gnupg/ ${HOME}/backup/gnupg/ logs: rsync ${RSYNC_SW} cheshire:/var/www/ ${HOME}/backup/www/ rsync ${RSYNC_SW} cheshire:~/cvs/ ${HOME}/backup/cvs/ rsync ${RSYNC_SW} cheshire:~/log/ ${HOME}/backup/log/ ifarchive: rsync ${RSYNC_SW} cheshire:~/ifarchive/ ${HOME}/mirrors/ifarchive/ ~/bin/backup
274. #!/usr/bin/mpg123 -z -@ /usr/bin/music/outkast/ms.jackson.mp3 /usr/bin/music/devøshout.mp3 /usr/bin/music/talking_heads/television_man.mp3 ... ~/bin/bestsongs #!/usr/bin/whatever
275. #!/usr/bin/mpg123 -z -@ /usr/bin/music/outkast/ms.jackson.mp3 /usr/bin/music/devøshout.mp3 /usr/bin/music/talking_heads/television_man.mp3 ... ~/bin/bestsongs #!/usr/bin/whatever addsong() { if [ “$1” != “” -a -r “$1” ]; then echo $1 >> ~/bin/bestsongs; else echo can’t add file }
276. #!/usr/bin/perl #!/usr/bin/whatever #!/usr/bin/python #!/usr/bin/ruby #!/usr/bin/clisp
277. More Slides things that deserve more time
278. Globbing
279. Globbing - * and ?
280. Globbing - * and ? - [ABC]
281. Globbing - * and ? - [ABC] - {xyz}
282. Globbing - * and ? - [ABC] - {xyz} - zsh globbing
283. Environment Variables
284. Environment Variables - shell vars v. environment vars
285. Environment Variables - shell vars v. environment vars - $x and ${x}
286. Environment Variables - shell vars v. environment vars - $x and ${x} - ${x:-default}
287. Environment Variables - shell vars v. environment vars - $x and ${x} - ${x:-default} - ${x:=default}
288. Environment Variables - shell vars v. environment vars - $x and ${x} - ${x:-default} - ${x:=default} - ${x:?epitaph}
289. Environment Variables - shell vars v. environment vars - $x and ${x} - ${x:-default} - ${x:=default} - ${x:?epitaph} - ${x:+iftrue}
290. Environment Variables - shell vars v. environment vars - $x and ${x} - ${x:-default} - ${x:=default} - ${x:?epitaph} - ${x:+iftrue} - ${x:offset:length}
291. STDIO
292. STDIO - `` and $()
293. STDIO - `` and $() - >&
294. STDIO - `` and $() - >& - << and <<-
295. STDIO - `` and $() - >& - << and <<- - command blocks { }
296. STDIO - `` and $() - >& - << and <<- - command blocks { } - the read builtin
297. Magic Nonsense
298. Magic Nonsense - (job&) # job into void
299. Magic Nonsense - (job&) # job into void - $((2+2))
300. Magic Nonsense - (job&) # job into void - $((2+2)) - “” versus ‘’
301. Magic Nonsense - (job&) # job into void - $((2+2)) - “” versus ‘’ - ugh! ‘abc’\’’def’
302. Magic Nonsense - (job&) # job into void - $((2+2)) - “” versus ‘’ - ugh! ‘abc’\’’def’ - eval
303. Magic Nonsense - (job&) # job into void - $((2+2)) - “” versus ‘’ - ugh! ‘abc’\’’def’ - eval - source
304. Precedence Hackery - command - builtin - enable