comparison unix-phil.ms @ 45:ade392f024aa

a lot of rework throughout the whole document
author meillo@marmaro.de
date Mon, 12 Apr 2010 09:33:01 +0200
parents 46e34e433231
children 98a1446744c7
comparison
equal deleted inserted replaced
44:46e34e433231 45:ade392f024aa
20 .if '\\$1'1' .nr PS +2 20 .if '\\$1'1' .nr PS +2
21 ._N \\$1 21 ._N \\$1
22 .if '\\$1'1' .nr PS -2 22 .if '\\$1'1' .nr PS -2
23 .. 23 ..
24 24
25 .am QP
26 .ps -1
27 ..
28
25 .\"---------------------------------------- 29 .\"----------------------------------------
26 30
27 .TL 31 .TL
28 .ps +4 32 .ps +4
29 Why the Unix Philosophy still matters 33 Why the Unix Philosophy still matters
63 .[ 67 .[
64 wikipedia 68 wikipedia
65 unix philosophy 69 unix philosophy
66 .] 70 .]
67 .QP 71 .QP
68 .ps -1
69 The \fIUnix philosophy\fP is a set of cultural norms and philosophical 72 The \fIUnix philosophy\fP is a set of cultural norms and philosophical
70 approaches to developing software based on the experience of leading 73 approaches to developing software based on the experience of leading
71 developers of the Unix operating system. 74 developers of the Unix operating system.
72 .PP 75 .PP
73 As there is no single definition of the Unix Philosophy, 76 As there is no single definition of the Unix Philosophy,
96 Especially, the main concepts are similar in all of them. 99 Especially, the main concepts are similar in all of them.
97 McIlroy's definition can surely be called the core of the Unix Philosophy, 100 McIlroy's definition can surely be called the core of the Unix Philosophy,
98 but the fundamental idea behind it all, is ``small is beautiful''. 101 but the fundamental idea behind it all, is ``small is beautiful''.
99 102
100 .PP 103 .PP
101 The Unix Philosophy tells how to design and write good software for Unix. 104 The Unix Philosophy explains how to design good software for Unix.
102 Many concepts described here base on facilities of Unix. 105 Many concepts described here, base on facilities of Unix.
103 Other operating systems may not offer such facilities, 106 Other operating systems may not offer such facilities,
104 hence it may not be possible to design software in the way of the 107 hence it may not be possible to design software in the way of the
105 Unix Philosophy for them. 108 Unix Philosophy for them.
106 .PP 109 .PP
107 The Unix Philosophy has an idea of how the process of software development 110 The Unix Philosophy has an idea of how the process of software development
108 should look like, but large parts of the philosophy are quite independent 111 should look like, but large parts of the philosophy are quite independent
109 from the development process used. 112 from a concrete development process.
110 However, one will soon recognize that some development processes work well 113 However, one will soon recognize that some development processes work well
111 with the ideas of the Unix Philosophy and support them, while others are 114 with the ideas of the Unix Philosophy and support them, while others are
112 at cross-purposes. 115 at cross-purposes.
113 Kent Beck's books about Extreme Programming are valuable supplimental 116 Kent Beck's books about Extreme Programming are valuable supplemental
114 resources. 117 resources on this topic.
115 .PP 118 .PP
116 The question of how to actually write code and how the code should looks 119 The question of how to actually write code and how the code should looks
117 like internally, are out of focus here. 120 like in detail, are out of focus here.
118 ``The Practice of Programming'' by Kernighan and Pike, 121 ``The Practice of Programming'' by Kernighan and Pike,
119 .[ 122 .[
120 kernighan pike 123 kernighan pike
121 practice of programming 124 practice of programming
122 .] 125 .]
133 Software design is the planning of how the internal structure 136 Software design is the planning of how the internal structure
134 and external interfaces of a software should look like. 137 and external interfaces of a software should look like.
135 It has nothing to do with visual appearance. 138 It has nothing to do with visual appearance.
136 If we take a program as a car, then its color is of no matter. 139 If we take a program as a car, then its color is of no matter.
137 Its design would be the car's size, its shape, the locations of doors, 140 Its design would be the car's size, its shape, the locations of doors,
138 the passenger/space ratio, the luggage capacity, and so forth. 141 the passenger/space ratio, the available controls and instruments,
142 and so forth.
139 .PP 143 .PP
140 Why should software get designed at all? 144 Why should software get designed at all?
141 It is general knowledge, that even a bad plan is better than no plan. 145 It is general knowledge, that even a bad plan is better than no plan.
142 Not designing software means programming without plan. 146 Not designing software means programming without plan.
143 This will pretty sure lead to horrible results. 147 This will pretty sure lead to horrible results.
144 Horrible to use and horrible to maintain. 148 Software that is horrible to use and horrible to maintain.
145 These two aspects are the visible ones. 149 These two aspects are the visible ones.
146 Often invisible are the wasted possible gains. 150 Often invisible though, are the wasted possible gains.
147 Good software design can make these gains available. 151 Good software design can make these gains available.
148 .PP 152 .PP
149 A software's design deals with quality properties. 153 A software's design deals with quality properties.
150 Good design leads to good quality, and quality is important. 154 Good design leads to good quality, and quality is important.
151 Any car may be able to drive from A to B, 155 Any car may be able to drive from A to B,
164 Someone has a problem and needs a tool to solve it. 168 Someone has a problem and needs a tool to solve it.
165 Being able to solve the problem is the main functional goal. 169 Being able to solve the problem is the main functional goal.
166 It is the driving force behind all programming effort. 170 It is the driving force behind all programming effort.
167 Functional requirements are easier to define and to verify. 171 Functional requirements are easier to define and to verify.
168 .IP \(bu 172 .IP \(bu
169 Non-functional requirements are also called \fIquality\fP requirements. 173 Non-functional requirements are called \fIquality\fP requirements, too.
170 The quality of a software are the properties that are not directly related to 174 The quality of a software are the properties that are not directly related to
171 the software's basic functions. 175 the software's basic functions.
172 Tools of bad quality often solve the problems they were written for, 176 Tools of bad quality often do solve the problems they were written for,
173 but introduce problems and difficulties for usage and development, later on. 177 but introduce problems and difficulties for usage and development, later on.
174 Quality aspects are often overlooked at first sight, 178 Quality aspects are often overlooked at first sight,
175 and they are often difficult to define clearly and to verify. 179 and are often difficult to define clearly and to verify.
176 .PP 180 .PP
177 Quality is of few matter when the software gets built initially, 181 Quality is hardly interesting when the software gets built initially,
178 but it is of matter for usage and maintenance of the software. 182 but it has a high impact on usability and maintenance of the software, later.
179 A short-sighted might see in developing a software mainly building something up. 183 A short-sighted might see in developing a software, mainly building something up.
180 But experience shows, that building the software the first time is 184 But experience shows, that building the software the first time is
181 only a small amount of the overall work. 185 only a small amount of the overall work.
182 Bug fixing, extending, rebuilding of parts 186 Bug fixing, extending, rebuilding of parts \(en maintenance work \(en
183 \(en maintenance work, for short \(en
184 does soon take over the major part of the time spent on a software. 187 does soon take over the major part of the time spent on a software.
185 Not to forget the usage of the software. 188 And of course, the time spent actually using the software.
186 These processes are highly influenced by the software's quality. 189 These processes are highly influenced by the software's quality.
187 Thus, quality must not be neglected. 190 Thus, quality must not be neglected.
188 The problem with quality is that you hardly ``stumble over'' 191 However, the problem with quality is that you hardly ``stumble over''
189 bad quality during the first build, 192 bad quality during the first build,
190 but this is the time when you should care about good quality most. 193 although this is the time when you should care about good quality most.
191 .PP 194 .PP
192 Software design is less the basic function of a software \(en 195 Software design has little to do with the basic function of a software \(en
193 this requirement will get satisfied anyway. 196 this requirement will get satisfied anyway.
194 Software design is more about quality aspects of the software. 197 Software design is more about quality aspects of the software.
195 Good design leads to good quality, bad design to bad quality. 198 Good design leads to good quality, bad design to bad quality.
196 The primary functions of the software will be affected modestly by bad quality, 199 The primary functions of the software will be affected modestly by bad quality,
197 but good quality can provide a lot of additional gain, 200 but good quality can provide a lot of additional gain,
198 even at places where one never expected it. 201 even at places where one never expected it.
199 .PP 202 .PP
200 The ISO/IEC 9126-1 standard, part 1, 203 The ISO/IEC\|9126-1 standard, part\|1,
201 .[ 204 .[
202 iso product quality 205 iso product quality
203 .] 206 .]
204 defines the quality model as consisting out of: 207 defines the quality model as consisting out of:
205 .IP \(bu 208 .IP \(bu
220 .IP \(bu 223 .IP \(bu
221 .I Portability 224 .I Portability
222 (adaptability, installability, co-existence, replaceability) 225 (adaptability, installability, co-existence, replaceability)
223 .LP 226 .LP
224 Good design can improve these properties of a software, 227 Good design can improve these properties of a software,
225 bad designed software probably suffers from not having them. 228 bad designed software likely suffers in these points.
226 .PP 229 .PP
227 One further goal of software design is consistency. 230 One further goal of software design is consistency.
228 Consistency eases understanding, working on, and using things. 231 Consistency eases understanding, working on, and using things.
229 Consistent internal structure and consistent interfaces to the outside 232 Consistent internal structure and consistent interfaces to the outside
230 can be provided by good design. 233 can be provided by good design.
231 .PP 234 .PP
232 Software should be well designed because good design avoids many 235 Software should be well designed because good design avoids many
233 problems during the software's lifetime. 236 problems during a software's lifetime.
234 And software should be well designed because good design can offer 237 And software should be well designed because good design can offer
235 much additional gain. 238 much additional gain.
236 Indeed, much effort should be spent into good design to make software more valuable. 239 Indeed, much effort should be spent into good design to make software more valuable.
237 The Unix Philosophy shows a way of how to design software well. 240 The Unix Philosophy shows a way of how to design software well.
238 It offers guidelines to achieve good quality and high gain for the effort spent. 241 It offers guidelines to achieve good quality and high gain for the effort spent.
277 .ps -1 280 .ps -1
278 ls | grep -v foo | wc -l 281 ls | grep -v foo | wc -l
279 .DE 282 .DE
280 Here, the list of files is filtered by 283 Here, the list of files is filtered by
281 .CW grep 284 .CW grep
282 to remove all that contain ``foo''. 285 to remove all lines that contain ``foo''.
283 The rest is the same as in the previous example. 286 The rest equals the previous example.
284 .PP 287 .PP
285 Finding the five largest entries in the current directory. 288 Finding the five largest entries in the current directory.
286 .DS 289 .DS
287 .CW 290 .CW
288 .ps -1 291 .ps -1
289 du -s * | sort -nr | sed 5q 292 du -s * | sort -nr | sed 5q
290 .DE 293 .DE
291 .CW "du -s * 294 .CW "du -s *
292 returns the recursively summed sizes of all files 295 returns the recursively summed sizes of all files in the current directory
293 \(en no matter if they are regular files or directories. 296 \(en no matter if they are regular files or directories.
294 .CW "sort -nr 297 .CW "sort -nr
295 sorts the list numerically in reverse order. 298 sorts the list numerically in reverse order (descending).
296 Finally, 299 Finally,
297 .CW "sed 5q 300 .CW "sed 5q
298 quits after it has printed the fifth line. 301 quits after it has printed the fifth line.
299 .PP 302 .PP
300 The presented command lines are examples of what Unix people would use 303 The presented command lines are examples of what Unix people would use
308 .PP 311 .PP
309 Pipes, and their extensive and easy use, are one of the great 312 Pipes, and their extensive and easy use, are one of the great
310 achievements of the Unix system. 313 achievements of the Unix system.
311 Pipes between programs have been possible in earlier operating systems, 314 Pipes between programs have been possible in earlier operating systems,
312 but it has never been a so central part of the concept. 315 but it has never been a so central part of the concept.
313 When, in the early seventies, Doug McIlroy introduced pipes for the 316 When, in the early seventies, Doug McIlroy introduced pipes into the
314 Unix system, 317 Unix system,
315 ``it was this concept and notation for linking several programs together 318 ``it was this concept and notation for linking several programs together
316 that transformed Unix from a basic file-sharing system to an entirely new way of computing.'' 319 that transformed Unix from a basic file-sharing system to an entirely new way of computing.''
317 .[ 320 .[
318 aughenbaugh 321 aughenbaugh
319 unix oral history 322 unix oral history
320 .] 323 .]
321 .PP 324 .PP
322 Being able to specify pipelines in an easy way is, 325 Being able to specify pipelines in an easy way is,
323 however, not enough by itself. 326 however, not enough by itself.
324 It is only one half. 327 It is only one half.
325 The other is the design of the programs that are used in the pipeline. 328 The other is the design of the programs that are used in the pipeline.
326 They have to interfaces that allows them to be used in such a way. 329 They need interfaces that allow them to be used in such a way.
327 330
328 .NH 2 331 .NH 2
329 Interface design 332 Interface design
330 .XS 333 .XS
331 \*(SN Interface design 334 \*(SN Interface design
332 .XE 335 .XE
333 .LP 336 .LP
334 Unix is, first of all, simple \(en Everything is a file. 337 Unix is, first of all, simple \(en Everything is a file.
335 Files are sequences of bytes, without any special structure. 338 Files are sequences of bytes, without any special structure.
336 Programs should be filters, which read a stream of bytes from ``standard input'' (stdin) 339 Programs should be filters, which read a stream of bytes from standard input (stdin)
337 and write a stream of bytes to ``standard output'' (stdout). 340 and write a stream of bytes to standard output (stdout).
338 .PP
339 If the files \fIare\fP sequences of bytes, 341 If the files \fIare\fP sequences of bytes,
340 and the programs \fIare\fP filters on byte streams, 342 and the programs \fIare\fP filters on byte streams,
341 then there is exactly one standardized data interface. 343 then there is exactly one data interface.
342 Thus it is possible to combine them in any desired way. 344 Hence it is possible to combine programs in any desired way.
343 .PP 345 .PP
344 Even a handful of small programs will yield a large set of combinations, 346 Even a handful of small programs yields a large set of combinations,
345 and thus a large set of different functions. 347 and thus a large set of different functions.
346 This is leverage! 348 This is leverage!
347 If the programs are orthogonal to each other \(en the best case \(en 349 If the programs are orthogonal to each other \(en the best case \(en
348 then the set of different functions is greatest. 350 then the set of different functions is greatest.
349 .PP 351 .PP
350 Programs might also have a separate control interface, 352 Programs can also have a separate control interface,
351 besides their data interface. 353 besides their data interface.
352 The control interface is often called ``user interface'', 354 The control interface is often called ``user interface'',
353 because it is usually designed to be used by humans. 355 because it is usually designed to be used by humans.
354 The Unix Philosophy discourages to assume the user to be human. 356 The Unix Philosophy discourages to assume the user to be human.
355 Interactive use of software is slow use of software, 357 Interactive use of software is slow use of software,
356 because the program waits for user input most of the time. 358 because the program waits for user input most of the time.
357 Interactive software requires the user to be in front of the computer 359 Interactive software requires the user to be in front of the computer.
358 all the time.
359 Interactive software occupy the user's attention while they are running. 360 Interactive software occupy the user's attention while they are running.
360 .PP 361 .PP
361 Now we come back to the idea of using several small programs, combined, 362 Now to come back to the idea of combining several small programs,
362 to have a more specific function. 363 to have a more specific function.
363 If these single tools would all be interactive, 364 If these single tools would all be interactive,
364 how would the user control them? 365 how would the user control them?
365 It is not only a problem to control several programs at once if they run at the same time, 366 It is not only a problem to control several programs at once,
367 if they run at the same time,
366 it also very inefficient to have to control each of the single programs 368 it also very inefficient to have to control each of the single programs
367 that are intended to work as one large program. 369 that are intended to act as one large program.
368 Hence, the Unix Philosophy discourages programs to demand interactive use. 370 Hence, the Unix Philosophy discourages programs to demand interactive use.
369 The behavior of programs should be defined at invocation. 371 The behavior of programs should be defined at invocation.
370 This is done by specifying arguments (``command line switches'') to the program call. 372 This is done by specifying arguments to the program call
373 (command line switches).
371 Gancarz discusses this topic as ``avoid captive user interfaces''. 374 Gancarz discusses this topic as ``avoid captive user interfaces''.
372 .[ 375 .[
373 gancarz unix philosophy 376 gancarz unix philosophy
374 %P 88 ff. 377 %P 88 ff.
375 .] 378 .]
400 It is easier and less error-prone to write small programs. 403 It is easier and less error-prone to write small programs.
401 It is also easier and less error-prone to write a large set of small programs, 404 It is also easier and less error-prone to write a large set of small programs,
402 than to write one large program with all the functionality included. 405 than to write one large program with all the functionality included.
403 If the small programs are combinable, then they offer even a larger set 406 If the small programs are combinable, then they offer even a larger set
404 of functions than the single large program. 407 of functions than the single large program.
405 Hence, one gets two advantages out of writing small, combinable programs. 408 Hence, one gets two advantages out of writing small, combinable programs:
406 .PP 409 They are easier to write and they offer a greater set of functions through
407 There are two drawbacks of the toolchest approach. 410 combination.
408 First, one simple, standardized, unidirectional interface has to be sufficient. 411 .PP
412 But there are also two main drawbacks of the toolchest approach.
413 First, one simple, standardized interface has to be sufficient.
409 If one feels the need for more ``logic'' than a stream of bytes, 414 If one feels the need for more ``logic'' than a stream of bytes,
410 then a different approach might be of need. 415 then a different approach might be of need.
411 But it is also possible, that he just can not imagine a design where 416 But it is also possible, that he just can not imagine a design where
412 a stream of bytes is sufficient. 417 a stream of bytes is sufficient.
413 By becoming more familiar with the ``Unix style of thinking'', 418 By becoming more familiar with the ``Unix style of thinking'',
414 developers will more often and easier find simple designs where 419 developers will more often and easier find simple designs where
415 a stream of bytes is a sufficient interface. 420 a stream of bytes is a sufficient interface.
416 .PP 421 .PP
417 The second drawback of a toolchest affects the users. 422 The second drawback of a toolchest affects the users.
418 A toolchest is often more difficult to use for novices. 423 A toolchest is often more difficult to use.
419 It is necessary to become familiar with each of the tools, 424 It is necessary to become familiar with each of the tools,
420 to be able to use the right one in a given situation. 425 to be able to use the right one in a given situation.
421 Additionally, one needs to combine the tools in a senseful way on its own. 426 Additionally, one needs to combine the tools in a senseful way himself.
422 This is like a sharp knife \(en it is a powerful tool in the hand of a master, 427 This is like a sharp knife \(en it is a powerful tool in the hand of a
423 but of no good value in the hand of an unskilled. 428 master, but of no good value in the hand of an unskilled.
424 .PP 429 However, learning single, small tools of a toolchest is easier than
425 However, learning single, small tool of the toolchest is easier than
426 learning a complex tool. 430 learning a complex tool.
427 The user will have a basic understanding of a yet unknown tool, 431 And the user will already have a basic understanding of a yet unknown tool,
428 if the several tools of the toolchest have a common style. 432 if the tools of a toolchest have a common, consistent style.
429 He will be able to transfer knowledge over one tool to another. 433 He will be able to transfer knowledge over from one tool to another.
430 .PP 434 .PP
431 Moreover, the second drawback can be removed easily by adding wrappers 435 Moreover, the second drawback can be removed to a large extend
432 around the single tools. 436 by adding wrappers around the basic tools.
433 Novice users do not need to learn several tools if a professional wraps 437 Novice users do not need to learn several tools, if a professional wraps
434 the single commands into a more high-level script. 438 complete command lines into a higher-level script.
435 Note that the wrapper script still calls the small tools; 439 Note that the wrapper script still calls the small tools;
436 the wrapper script is just like a skin around. 440 it is just like a skin around them.
437 No complexity is added this way, 441 No complexity is added this way.
438 but new programs can get created out of existing one with very low effort. 442 But new programs can get created out of existing one with very low effort.
439 .PP 443 .PP
440 A wrapper script for finding the five largest entries in the current directory 444 A wrapper script for finding the five largest entries in the current directory
441 could look like this: 445 could look like this:
442 .DS 446 .DS
443 .CW 447 .CW
444 .ps -1 448 .ps -1
445 #!/bin/sh 449 #!/bin/sh
446 du -s * | sort -nr | sed 5q 450 du -s * | sort -nr | sed 5q
447 .DE 451 .DE
448 The script itself is just a text file that calls the command line 452 The script itself is just a text file that calls the command line,
449 a professional user would type in directly. 453 which a professional user would type in directly.
450 Making the program flexible on the number of entries it prints, 454 It is probably worth to make the program flexible on the number of
451 is easily possible: 455 entries it prints:
452 .DS 456 .DS
453 .CW 457 .CW
454 .ps -1 458 .ps -1
455 #!/bin/sh 459 #!/bin/sh
456 num=5 460 num=5
457 [ $# -eq 1 ] && num="$1" 461 [ $# -eq 1 ] && num="$1"
458 du -sh * | sort -nr | sed "${num}q" 462 du -sh * | sort -nr | sed "${num}q"
459 .DE 463 .DE
460 This script acts like the one before, when called without an argument. 464 This script acts like the one before, when called without an argument.
461 But one can also specify a numerical argument to define the number of lines to print. 465 But one can also specify a numerical argument to define the number of lines to print.
466 One can surely imagine even more flexible versions, however,
467 they will still relay on the external programs,
468 which do the actual work.
462 469
463 .NH 2 470 .NH 2
464 A powerful shell 471 A powerful shell
465 .XS 472 .XS
466 \*(SN A powerful shell 473 \*(SN A powerful shell
467 .XE 474 .XE
468 .LP 475 .LP
469 It was already said, that the Unix shell provides the possibility to 476 The Unix shell provides the possibility to combine small programs into large ones.
470 combine small programs into large ones easily. 477 But a powerful shell is a great feature in other ways, too.
471 A powerful shell is a great feature in other ways, too. 478 For instance by being scriptable.
472 .PP 479 Control statements are build into the shell.
473 For instance by including a scripting language. 480 The functions, however, are the normal programs of the system.
474 The control statements are build into the shell. 481 Thus, as the programs are already known,
475 The functions, however, are the normal programs, everyone can use on the system. 482 learning to program in the shell becomes easy.
476 Thus, the programs are known, so learning to program in the shell is easy.
477 Using normal programs as functions in the shell programming language 483 Using normal programs as functions in the shell programming language
478 is only possible because they are small and combinable tools in a toolchest style. 484 is only possible because they are small and combinable tools in a toolchest style.
479 .PP 485 .PP
480 The Unix shell encourages to write small scripts out of other programs, 486 The Unix shell encourages to write small scripts,
481 because it is so easy to do. 487 by combining existing programs, because it is so easy to do.
482 This is a great step towards automation. 488 This is a great step towards automation.
483 It is wonderful if the effort to automate a task equals the effort 489 It is wonderful if the effort to automate a task equals the effort
484 it takes to do it the second time by hand. 490 to do the task a second time by hand.
485 If it is so, then the user will be happy to automate everything he does more than once. 491 If this holds,
492 then the user will be happy to automate everything he does more than once.
486 .PP 493 .PP
487 Small programs that do one job well, standardized interfaces between them, 494 Small programs that do one job well, standardized interfaces between them,
488 a mechanism to combine parts to larger parts, and an easy way to automate tasks, 495 a mechanism to combine parts to larger parts, and an easy way to automate tasks,
489 this will inevitably produce software leverage. 496 this will inevitably produce software leverage.
490 Getting multiple times the benefit of an investment is a great offer. 497 Getting multiple times the benefit of an investment is a great offer.
491 .PP 498 .PP
492 The shell also encourages rapid prototyping. 499 The shell also encourages rapid prototyping.
493 Many well known programs started as quickly hacked shell scripts, 500 Many well known programs started as quickly hacked shell scripts,
494 and turned into ``real'' programs, written in C, later. 501 and turned into ``real'' programs, written in C, later.
495 Building a prototype first is a way to avoid the biggest problems 502 Building a prototype first, is a way to avoid the biggest problems
496 in application development. 503 in application development.
497 Fred Brooks writes in ``No Silver Bullet'': 504 Fred Brooks explains in ``No Silver Bullet'':
498 .[ 505 .[
499 brooks 506 brooks
500 no silver bullet 507 no silver bullet
501 .] 508 .]
502 .QP 509 .QP
503 .ps -1
504 The hardest single part of building a software system is deciding precisely what to build. 510 The hardest single part of building a software system is deciding precisely what to build.
505 No other part of the conceptual work is so difficult as establishing the detailed 511 No other part of the conceptual work is so difficult as establishing the detailed
506 technical requirements, [...]. 512 technical requirements, [...].
507 No other part of the work so cripples the resulting system if done wrong. 513 No other part of the work so cripples the resulting system if done wrong.
508 No other part is more difficult to rectify later. 514 No other part is more difficult to rectify later.
509 .PP 515 .PP
510 Writing a prototype is a great method to become familiar with the requirements 516 Writing a prototype is a great method for becoming familiar with the requirements
511 and to actually run into real problems. 517 and to run into real problems early.
512 Today, prototyping is often seen as a first step in building a software. 518 .PP
519 Prototyping is often seen as a first step in building a software.
513 This is, of course, good. 520 This is, of course, good.
514 However, the Unix Philosophy has an \fIadditional\fP perspective on prototyping: 521 However, the Unix Philosophy has an \fIadditional\fP perspective on prototyping:
515 After having built the prototype, one might notice, that the prototype is already 522 After having built the prototype, one might notice, that the prototype is already
516 \fIgood enough\fP. 523 \fIgood enough\fP.
517 Hence, no reimplementation, in a more sophisticated programming language, might be of need, 524 Hence, no reimplementation, in a more sophisticated programming language,
518 for the moment. 525 might be of need, at least for the moment.
519 Maybe later, it might be necessary to rewrite the software, but not now. 526 Maybe later, it might be necessary to rewrite the software, but not now.
520 .PP 527 By delaying further work, one keeps the flexibility to react on
521 By delaying further work, one keeps the flexibility to react easily on
522 changing requirements. 528 changing requirements.
523 Software parts that are not written will not miss the requirements. 529 Software parts that are not written will not miss the requirements.
524 530
525 .NH 2 531 .NH 2
526 Worse is better 532 Worse is better
527 .XS 533 .XS
528 \*(SN Worse is better 534 \*(SN Worse is better
529 .XE 535 .XE
530 .LP 536 .LP
531 The Unix Philosophy aims for the 80% solution; 537 The Unix Philosophy aims for the 90% solution;
532 others call it the ``Worse is better'' approach. 538 others call it the ``Worse is better'' approach.
533 .PP 539 Practical experience shows, that:
534 First, practical experience shows, that it is almost never possible to define the 540 .PP
541 (1) It is almost never possible to define the
535 requirements completely and correctly the first time. 542 requirements completely and correctly the first time.
536 Hence one should not try to; it will fail anyway. 543 Hence one should not try to; one will fail anyway.
537 Second, practical experience shows, that requirements change during time. 544 .PP
545 (2) Requirements change during time.
538 Hence it is best to delay requirement-based design decisions as long as possible. 546 Hence it is best to delay requirement-based design decisions as long as possible.
539 Also, the software should be small and flexible as long as possible 547 The software should be small and flexible as long as possible
540 to react on changing requirements. 548 to react on changing requirements.
541 Shell scripts, for example, are more easily adjusted as C programs. 549 Shell scripts, for example, are more easily adjusted as C programs.
542 Third, practical experience shows, that maintenance is hard work. 550 .PP
543 Hence, one should keep the amount of software as small as possible; 551 (3) Maintenance work is hard work.
552 Hence, one should keep the amount of code as small as possible;
544 it should just fulfill the \fIcurrent\fP requirements. 553 it should just fulfill the \fIcurrent\fP requirements.
545 Software parts that will be written later, do not need maintenance now. 554 Software parts that will be written in future,
555 do not need maintenance till then.
546 .PP 556 .PP
547 Starting with a prototype in a scripting language has several advantages: 557 Starting with a prototype in a scripting language has several advantages:
548 .IP \(bu 558 .IP \(bu
549 As the initial effort is low, one will likely start right away. 559 As the initial effort is low, one will likely start right away.
550 .IP \(bu 560 .IP \(bu
551 As working parts are available soon, the real requirements can get identified soon. 561 As working parts are available soon, the real requirements can get identified soon.
552 .IP \(bu 562 .IP \(bu
553 When a software is usable, it gets used, and thus tested. 563 When a software is usable and valuable, it gets used, and thus tested.
554 Hence problems will be found at early stages of the development. 564 Hence problems will be found at early stages of the development.
555 .IP \(bu 565 .IP \(bu
556 The prototype might be enough for the moment, 566 The prototype might be enough for the moment,
557 thus further work on the software can be delayed to a time 567 thus further work on the software can get delayed to a time
558 when one knows better about the requirements and problems, 568 when one knows better about the requirements and problems,
559 than now. 569 than now.
560 .IP \(bu 570 .IP \(bu
561 Implementing now only the parts that are actually needed now, 571 Implementing now only the parts that are actually needed at the moment,
562 requires fewer maintenance work. 572 introduces fewer programming and maintenance work.
563 .IP \(bu 573 .IP \(bu
564 If the global situation changes so that the software is not needed anymore, 574 If the global situation changes so that the software is not needed anymore,
565 then less effort was spent into the project, than it would have be 575 then less effort was spent into the project, than it would have be
566 when a different approach had been used. 576 when a different approach had been used.
567 577
573 .LP 583 .LP
574 So far it was talked about \fIwriting\fP or \fIbuilding\fP software. 584 So far it was talked about \fIwriting\fP or \fIbuilding\fP software.
575 Although these are just verbs, they do imply a specific view on the work process 585 Although these are just verbs, they do imply a specific view on the work process
576 they describe. 586 they describe.
577 The better verb, however, is to \fIgrow\fP. 587 The better verb, however, is to \fIgrow\fP.
578 .PP
579 Creating software in the sense of the Unix Philosophy is an incremental process. 588 Creating software in the sense of the Unix Philosophy is an incremental process.
580 It starts with a first prototype, which evolves as requirements change. 589 It starts with a first prototype, which evolves as requirements change.
581 A quickly hacked shell script might become a large, sophisticated, 590 A quickly hacked shell script might become a large, sophisticated,
582 compiled program this way. 591 compiled program this way.
583 Its lifetime begins with the initial prototype and ends when the software is not used anymore. 592 Its lifetime begins with the initial prototype and ends when the software is not used anymore.
584 While being alive it will get extended, rearranged, rebuilt (from scratch). 593 While being alive it will get extended, rearranged, rebuilt.
585 Growing software matches the view that ``software is never finished. It is only released.'' 594 Growing software matches the view that ``software is never finished. It is only released.''
586 .[ 595 .[
587 gancarz 596 gancarz
588 unix philosophy 597 unix philosophy
589 %P 26 598 %P 26
626 (2) 635 (2)
627 .I "Portability of data 636 .I "Portability of data
628 is best achieved by avoiding binary representations 637 is best achieved by avoiding binary representations
629 to store data, because binary representations differ from machine to machine. 638 to store data, because binary representations differ from machine to machine.
630 Textual representation is favored. 639 Textual representation is favored.
631 Historically, ASCII was the charset of choice. 640 Historically, \s-1ASCII\s0 was the charset of choice.
632 In the future, UTF-8 might be the better choice, however. 641 For the future, \s-1UTF\s0-8 might be the better choice.
633 Important is that it is a plain text representation in a 642 Important is that it is a plain text representation in a
634 very common charset encoding. 643 very common charset encoding.
635 Apart from being able to transfer data between machines, 644 Apart from being able to transfer data between machines,
636 readable data has the great advantage, that humans are able 645 readable data has the great advantage, that humans are able to directly
637 to directly edit it with text editors and other tools from the Unix toolchest. 646 read and edit it with text editors and other tools from the Unix toolchest.
638 .\" gancarz tenet 5 647 .\" gancarz tenet 5
639 .PP 648 .PP
640 (3) 649 (3)
641 A large 650 A large
642 .I "range of usability 651 .I "range of usability
643 ensures good adaptation, and thus good survival. 652 ensures good adaptation, and thus good survival.
644 It is a special distinction if a software becomes used in fields of action, 653 It is a special distinction if a software becomes used in fields of action,
645 the original authors did never imagine. 654 the original authors did never imagine.
646 Software that solves problems in a general way will likely be used 655 Software that solves problems in a general way will likely be used
647 for all kinds of similar problems. 656 for many kinds of similar problems.
648 Being too specific limits the range of uses. 657 Being too specific limits the range of usability.
649 Requirements change through time, thus use cases change or even vanish. 658 Requirements change through time, thus use cases change or even vanish.
650 A good example in this point is Allman's sendmail. 659 As a good example in this point,
651 Allman identifies flexibility to be one major reason for sendmail's success: 660 Allman identifies flexibility to be one major reason for sendmail's success:
652 .[ 661 .[
653 allman 662 allman
654 sendmail 663 sendmail
655 .] 664 .]
656 .QP 665 .QP
657 .ps -1
658 Second, I limited myself to the routing function [...]. 666 Second, I limited myself to the routing function [...].
659 This was a departure from the dominant thought of the time, [...]. 667 This was a departure from the dominant thought of the time, [...].
660 .QP 668 .QP
661 .ps -1 669 Third, the sendmail configuration file was flexible enough to adapt
662 Third, the sendmail configuration file was flexible enough to adopt
663 to a rapidly changing world [...]. 670 to a rapidly changing world [...].
664 .LP 671 .LP
665 Successful software adopts itself to the changing world. 672 Successful software adapts itself to the changing world.
666 .PP 673 .PP
667 (4) 674 (4)
668 .I "Reuse of parts 675 .I "Reuse of parts
669 is even one step further. 676 is even one step further.
670 A software may completely lose its field of action, 677 A software may completely lose its field of action,
671 but parts of which the software is build may be general and independent enough 678 but parts of which the software is build may be general and independent enough
672 to survive this death. 679 to survive this death.
673 If software is build by combining small independent programs, 680 If software is build by combining small independent programs,
674 then there are parts readily available for reuse. 681 then these parts are readily available for reuse.
675 Who cares if the large program is a failure, 682 Who cares if the large program is a failure,
676 but parts of it become successful instead? 683 but parts of it become successful instead?
677 684
678 .NH 2 685 .NH 2
679 Summary 686 Summary
680 .XS 687 .XS
681 \*(SN Summary 688 \*(SN Summary
682 .XE 689 .XE
683 .LP 690 .LP
684 This chapter explained the central ideas of the Unix Philosophy. 691 This chapter explained central ideas of the Unix Philosophy.
685 For each of the ideas, it was exposed what advantages they introduce. 692 For each of the ideas, the advantages they introduce were explained.
686 The Unix Philosophy are guidelines that help to write valuable software. 693 The Unix Philosophy are guidelines that help to write more valuable software.
687 From the view point of a software developer or software designer, 694 From the view point of a software developer or software designer,
688 the Unix Philosophy provides answers to many software design problem. 695 the Unix Philosophy provides answers to many software design problem.
689 .PP 696 .PP
690 The various ideas of the Unix Philosophy are very interweaved 697 The various ideas of the Unix Philosophy are very interweaved
691 and can hardly be applied independently. 698 and can hardly be applied independently.
692 However, the probably most important messages are: 699 However, the probably most important messages are:
700 .I "``Keep it simple!''" ,
693 .I "``Do one thing well!''" , 701 .I "``Do one thing well!''" ,
694 .I "``Keep it simple!''" ,
695 and 702 and
696 .I "``Use software leverage!'' 703 .I "``Use software leverage!''
697 704
698 705
699 706
713 .PP 720 .PP
714 This first case study is about the mail user agents (\s-1MUA\s0) 721 This first case study is about the mail user agents (\s-1MUA\s0)
715 \s-1MH\s0 (``mail handler'') and its descendent \fInmh\fP 722 \s-1MH\s0 (``mail handler'') and its descendent \fInmh\fP
716 (``new mail handler''). 723 (``new mail handler'').
717 \s-1MUA\s0s provide functions to read, compose, and organize mail, 724 \s-1MUA\s0s provide functions to read, compose, and organize mail,
718 but (ideally) not to transfer. 725 but (ideally) not to transfer it.
719 In this document, the name \s-1MH\s0 will be used for both of them. 726 In this document, the name \s-1MH\s0 will be used to include nmh.
720 A distinction will only be made if differences between 727 A distinction will only be made if differences between
721 them are described. 728 \s-1MH\s0 and nmh are described.
722 729
723 730
724 .NH 2 731 .NH 2
725 Historical background 732 Historical background
726 .XS 733 .XS
733 .[ 740 .[
734 salus 741 salus
735 quarter century of unix 742 quarter century of unix
736 %P 41 f. 743 %P 41 f.
737 .] 744 .]
738 It was a small program that either prints the user's mailbox file 745 It was a small program that either printed the user's mailbox file
739 or appends text to someone elses mailbox file, 746 or appended text to someone elses mailbox file,
740 depending on the command line arguments. 747 depending on the command line arguments.
741 .[ 748 .[
742 manual mail(1) 749 manual mail(1)
743 .] 750 .]
744 It was a program that did one job well. 751 It was a program that did one job well.
745 This job was emailing, which was very simple then. 752 This job was emailing, which was very simple then.
746 .PP 753 .PP
747 Later, emailing became more powerful, and thus more complex. 754 Later, emailing became more powerful, and thus more complex.
748 The simple \f(CWmail\fP, which knew nothing of subjects, 755 The simple \f(CWmail\fP, which knew nothing of subjects,
749 independent handling of single messages, 756 independent handling of single messages,
750 and long-time storage of them, was not powerful enough anymore. 757 and long-time email storage, was not powerful enough anymore.
751 At Berkeley, Kurt Shoens wrote \fIMail\fP (with capital `M') 758 In 1978 at Berkeley, Kurt Shoens wrote \fIMail\fP (with capital `M')
752 in 1978 to provide additional functions for emailing. 759 to provide additional functions for emailing.
753 Mail was still one program, but now it was large and did 760 Mail was still one program, but now it was large and did
754 several jobs. 761 several jobs.
755 Its user interface is modeled after the one of \fIed\fP. 762 Its user interface is modeled after the one of \fIed\fP.
756 It is designed for humans, but is still scriptable. 763 It is designed for humans, but is still scriptable.
757 \fImailx\fP is the adaptation of Berkeley Mail into System V. 764 \fImailx\fP is the adaptation of Berkeley Mail into System V.
766 A different way was taken by the people of \s-1RAND\s0 Corporation. 773 A different way was taken by the people of \s-1RAND\s0 Corporation.
767 In the beginning, they also had used a monolithic mail system, 774 In the beginning, they also had used a monolithic mail system,
768 called \s-1MS\s0 (for ``mail system''). 775 called \s-1MS\s0 (for ``mail system'').
769 But in 1977, Stockton Gaines and Norman Shapiro 776 But in 1977, Stockton Gaines and Norman Shapiro
770 came up with a proposal of a new email system concept \(en 777 came up with a proposal of a new email system concept \(en
771 one that honors the Unix Philosophy. 778 one that honored the Unix Philosophy.
772 The concept was implemented by Bruce Borden in 1978 and 1979. 779 The concept was implemented by Bruce Borden in 1978 and 1979.
773 This was the birth of \s-1MH\s0 \(en the ``mail handler''. 780 This was the birth of \s-1MH\s0 \(en the ``mail handler''.
774 .PP 781 .PP
775 Since then, \s-1RAND\s0, the University of California at Irvine and 782 Since then, \s-1RAND\s0, the University of California at Irvine and
776 at Berkeley, and several others have contributed to the software. 783 at Berkeley, and several others have contributed to the software.
777 However, it's core concepts remained the same. 784 However, it's core concepts remained the same.
778 In the late 90s, when development of \s-1MH\s0 slowed down, 785 In the late 90s, when development of \s-1MH\s0 slowed down,
779 Richard Coleman started with \fInmh\fP, the new mail handler. 786 Richard Coleman started with \fInmh\fP, the new mail handler.
780 His goal was to improve \s-1MH\s0, especially in regard of 787 His goal was to improve \s-1MH\s0 especially in regard of
781 the requirements of modern emailing. 788 the requirements of modern emailing.
782 Today, nmh is developed by various people on the Internet. 789 Today, nmh is developed by various people on the Internet.
783 .[ 790 .[
784 ware 791 ware
785 rand history 792 rand history
820 .IP \(bu 827 .IP \(bu
821 .CW folder : 828 .CW folder :
822 change current folder 829 change current folder
823 .IP \(bu 830 .IP \(bu
824 .CW refile : 831 .CW refile :
825 refile message into folder 832 refile message into different folder
826 .IP \(bu 833 .IP \(bu
827 .CW rmm : 834 .CW rmm :
828 remove message 835 remove message
829 .IP \(bu 836 .IP \(bu
830 .CW comp : 837 .CW comp :
831 compose a new message 838 compose new message
832 .IP \(bu 839 .IP \(bu
833 .CW repl : 840 .CW repl :
834 reply to a message 841 reply to message
835 .IP \(bu 842 .IP \(bu
836 .CW forw : 843 .CW forw :
837 forward a message 844 forward message
838 .IP \(bu 845 .IP \(bu
839 .CW send : 846 .CW send :
840 send a prepared message (this is how mail leaves the system) 847 send prepared message (this is how mail leaves the system)
841 .LP 848 .LP
842 \s-1MH\s0 has no special user interface like monolithic \s-1MUA\s0s have. 849 \s-1MH\s0 has no special user interface like monolithic \s-1MUA\s0s have.
843 The user does not leave the shell to run \s-1MH\s0, 850 The user does not leave the shell to run \s-1MH\s0,
844 but he uses the various \s-1MH\s0 programs within the shell. 851 instead he uses the various \s-1MH\s0 programs within the shell.
845 Using a monolithic program with a captive user interface 852 Using a monolithic program with a captive user interface
846 means ``entering'' the program, using it, and ``exiting'' the program. 853 means ``entering'' the program, using it, and ``exiting'' the program.
847 Using toolchests like \s-1MH\s0 means running programs, 854 Using toolchests like \s-1MH\s0 means running programs,
848 alone or in combination with others, even from other toolchests, 855 alone or in combination with others, also from other toolchests,
849 without leaving the shell. 856 without leaving the shell.
850 857
851 .NH 2 858 .NH 2
852 Data storage 859 Data storage
853 .XS 860 .XS
857 \s-1MH\s0's mail storage is a directory tree under the user's 864 \s-1MH\s0's mail storage is a directory tree under the user's
858 \s-1MH\s0 directory (usually \f(CW$HOME/Mail\fP), 865 \s-1MH\s0 directory (usually \f(CW$HOME/Mail\fP),
859 where mail folders are directories and mail messages are text files 866 where mail folders are directories and mail messages are text files
860 within them. 867 within them.
861 Each mail folder contains a file \f(CW.mh_sequences\fP which lists 868 Each mail folder contains a file \f(CW.mh_sequences\fP which lists
862 the public message sequences of that folder, for instance new messages. 869 the public message sequences of that folder,
870 for instance the \fIunseen\fP sequence for new messages.
863 Mail messages are text files located in a mail folder. 871 Mail messages are text files located in a mail folder.
864 The files contain the messages as they were received. 872 The files contain the messages as they were received.
865 They are numbered in ascending order in each folder. 873 They are named by ascending numbers in each folder.
866 .PP 874 .PP
867 This mailbox format is called ``\s-1MH\s0'' after the \s-1MUA\s0. 875 This mailbox format is called ``\s-1MH\s0'' after the \s-1MUA\s0.
868 Alternatives are \fImbox\fP and \fImaildir\fP. 876 Alternatives are \fImbox\fP and \fImaildir\fP.
869 In the mbox format all messages are stored within one file. 877 In the mbox format all messages are stored within one file.
870 This was a good solution in the early days, when messages 878 This was a good solution in the early days, when messages
873 of attachments, it is a bad solution. 881 of attachments, it is a bad solution.
874 Another disadvantage of the mbox format is that it is 882 Another disadvantage of the mbox format is that it is
875 more difficult to write tools that work on mail messages, 883 more difficult to write tools that work on mail messages,
876 because it is always necessary to first find and extract 884 because it is always necessary to first find and extract
877 the relevant message in the mbox file. 885 the relevant message in the mbox file.
878 With the \s-1MH\s0 mailbox format, 886 With the \s-1MH\s0 mailbox format, each message is a separate file.
879 each message is a self-standing item, by definition.
880 Also, the problem of concurrent access to one mailbox is 887 Also, the problem of concurrent access to one mailbox is
881 reduced to the problem of concurrent access to one message. 888 reduced to the problem of concurrent access to one message.
882 Maildir is generally similar to \s-1MH\s0's format, 889 The maildir format is generally similar to the \s-1MH\s0 format,
883 but modified towards guaranteed reliability. 890 but modified towards guaranteed reliability.
884 This involves some complexity, unfortunately. 891 This involves some complexity, unfortunately.
885 .PP 892 .PP
886 Working with \s-1MH\s0's toolchest on mailboxes is much like 893 Working with \s-1MH\s0's toolchest on mailboxes is much like
887 working with Unix' toolchest on directory trees: 894 working with Unix' toolchest on directory trees:
889 \f(CWshow\fP is like \f(CWcat\fP, 896 \f(CWshow\fP is like \f(CWcat\fP,
890 \f(CWfolder\fP is like \f(CWcd\fP and \f(CWpwd\fP, 897 \f(CWfolder\fP is like \f(CWcd\fP and \f(CWpwd\fP,
891 \f(CWrefile\fP is like \f(CWmv\fP, 898 \f(CWrefile\fP is like \f(CWmv\fP,
892 and \f(CWrmm\fP is like \f(CWrm\fP. 899 and \f(CWrmm\fP is like \f(CWrm\fP.
893 .PP 900 .PP
894 The context of tools in Unix consists mainly the current working directory, 901 \s-1MH\s0 extends the context of processes in Unix by two more items,
895 the user identification, and the environment variables. 902 for its tools:
896 \s-1MH\s0 extends this context by two more items:
897 .IP \(bu 903 .IP \(bu
898 The current mail folder, which is similar to the current working directory. 904 The current mail folder, which is similar to the current working directory.
899 For mail folders, \f(CWfolder\fP provides the corresponding functionality 905 For mail folders, \f(CWfolder\fP provides the corresponding functionality
900 of \f(CWcd\fP and \f(CWpwd\fP for directories. 906 of \f(CWcd\fP and \f(CWpwd\fP for directories.
901 .IP \(bu 907 .IP \(bu
902 Sequences, which are named sets of messages in a mail folder. 908 Sequences, which are named sets of messages in a mail folder.
903 The current message, relative to a mail folder, is a special sequence. 909 The current message, relative to a mail folder, is a special sequence.
904 It enables commands like \f(CWnext\fP and \f(CWprev\fP. 910 It enables commands like \f(CWnext\fP and \f(CWprev\fP.
905 .LP 911 .LP
906 In contrast to Unix' context, which is chained to the shell session, 912 In contrast to Unix' context, which is maintained by the kernel,
907 \s-1MH\s0's context is independent. 913 \s-1MH\s0's context must be maintained by the tools themselves.
908 Usually there is one context for each user, but a user can have many 914 Usually there is one context per user, which resides in his
909 contexts. 915 \f(CWcontext\fP file in the \s-1MH\s0 directory,
910 Public sequences are an exception, as they belong to the mail folder. 916 but a user can have several contexts, too.
917 Public sequences are an exception, as they belong to a mail folder,
918 and reside in the \f(CW.mh_sequences\fP file there.
911 .[ 919 .[
912 man page mh-profile mh-sequence 920 man page mh-profile mh-sequence
913 .] 921 .]
914 922
915 .NH 2 923 .NH 2
916 Discussion of the design 924 Discussion of the design
917 .XS 925 .XS
918 \*(SN Discussion of the design 926 \*(SN Discussion of the design
919 .XE 927 .XE
920 .LP 928 .LP
921 The following paragraphs discuss \s-1MH\s0 in regard to the tenets 929 This section discusses \s-1MH\s0 in regard to the tenets
922 of the Unix Philosophy which Gancarz identified. 930 of the Unix Philosophy that Gancarz identified.
923 931
924 .PP 932 .PP
925 .B "Small is beautiful 933 .B "Small is beautiful
926 and 934 and
927 .B "do one thing well 935 .B "do one thing well
928 are two design goals that are directly visible in \s-1MH\s0. 936 are two design goals that are directly visible in \s-1MH\s0.
929 Gancarz actually presents \s-1MH\s0 as example under the headline 937 Gancarz actually presents \s-1MH\s0 in his book as example under the
930 ``Making UNIX Do One Thing Well'': 938 headline ``Making \s-1UNIX\s0 Do One Thing Well'':
931 .[ 939 .[
932 gancarz 940 gancarz
933 unix philosophy 941 unix philosophy
934 %P 125 942 %P 125
935 .] 943 .]
936 .QP 944 .QP
937 .ps -1
938 [\s-1MH\s0] consists of a series of programs which 945 [\s-1MH\s0] consists of a series of programs which
939 when combined give the user an enormous ability 946 when combined give the user an enormous ability
940 to manipulate electronic mail messages. 947 to manipulate electronic mail messages.
941 A complex application, it shows that not only is it 948 A complex application, it shows that not only is it
942 possible to build large applications from smaller 949 possible to build large applications from smaller
943 components, but also that such designs are actually preferable. 950 components, but also that such designs are actually preferable.
944 .LP 951 .LP
945 The various small programs of \s-1MH\s0 were relatively easy 952 The various programs of \s-1MH\s0 were relatively easy to write,
946 to write, because each of them is small, limited to one function, 953 because each of them is small, limited to one function,
947 and has clear boundaries. 954 and has clear boundaries.
948 For the same reasons, they are also good to maintain. 955 For the same reasons, they are also good to maintain.
949 Further more, the system can easily get extended. 956 Further more, the system can easily get extended.
950 One only needs to put a new program into the toolchest. 957 One only needs to put a new program into the toolchest.
951 This was done, for instance, when \s-1MIME\s0 support was added 958 This was done, for instance, when \s-1MIME\s0 support was added
952 (e.g. \f(CWmhbuild\fP). 959 (e.g. \f(CWmhbuild\fP).
953 Also, different programs can exist to do the basically same job 960 Also, different programs can exist to do the basically same job
954 in different ways (e.g. in nmh: \f(CWshow\fP and \f(CWmhshow\fP). 961 in different ways (e.g. in nmh: \f(CWshow\fP and \f(CWmhshow\fP).
962 .PP
955 If someone needs a mail system with some additionally 963 If someone needs a mail system with some additionally
956 functions that are available nowhere yet, he best takes a 964 functions that are not available anywhere yet, he best expands a
957 toolchest system like \s-1MH\s0 where he can add the 965 toolchest system like \s-1MH\s0.
958 functionality with little work. 966 There he can add new functionality by simply adding additional
967 programs to the toolchest.
968 There he does not risk to break existing functionality by doing so.
959 969
960 .PP 970 .PP
961 .B "Store data in flat text files 971 .B "Store data in flat text files
962 is followed by \s-1MH\s0. 972 is followed by \s-1MH\s0.
963 This is not surprising, because email messages are already plain text. 973 This is not surprising, because email messages are already plain text.
964 \s-1MH\s0 stores the messages as it receives them, 974 \s-1MH\s0 stores the messages as it receives them,
965 thus any other tool that works on RFC 2822 mail messages can operate 975 thus any other tool that works on \s-1RFC\s0\|2822 mail messages can operate
966 on the messages in an \s-1MH\s0 mailbox. 976 on the messages in an \s-1MH\s0 mailbox.
967 All other files \s-1MH\s0 uses are plain text too. 977 All other files \s-1MH\s0 uses are plain text, too.
968 It is therefore possible and encouraged to use the text processing 978 It is therefore possible and encouraged to use the text processing
969 tools of Unix' toolchest to extend \s-1MH\s0's toolchest. 979 tools of Unix' toolchest to extend \s-1MH\s0's toolchest.
970 980
971 .PP 981 .PP
972 .B "Avoid captive user interfaces" . 982 .B "Avoid captive user interfaces" .
973 \s-1MH\s0 is perfectly suited for non-interactive use. 983 \s-1MH\s0 is perfectly suited for non-interactive use.
974 It offers all functions directly and without captive user interfaces. 984 It offers all functions directly and without captive user interfaces.
975 If, nonetheless, users want a graphical user interface, 985 If, nonetheless, users want a graphical user interface,
976 they can have it with \fIxmh\fP or \fIexmh\fP, too. 986 they can have it with \fIxmh\fP or \fIexmh\fP.
977 These are graphical frontends for the \s-1MH\s0 toolchest. 987 These are graphical frontends for the \s-1MH\s0 toolchest.
978 This means, all email-related work is still done by \s-1MH\s0 tools, 988 This means, all email-related work is still done by \s-1MH\s0 tools,
979 but the frontend issues the appropriate calls when the user 989 but the frontend calls the appropriate commands when the user
980 clicks on buttons. 990 clicks on buttons.
991 .PP
981 Providing easy-to-use user interfaces in form of frontends is a good 992 Providing easy-to-use user interfaces in form of frontends is a good
982 approach, because it does not limit the power of the backend itself. 993 approach, because it does not limit the power of the backend itself.
983 The frontend will anyway only be able to make a subset of the 994 The frontend will anyway only be able to make a subset of the
984 backend's power and flexibility available to the user. 995 backend's power and flexibility available to the user.
985 But if it is a separate program, 996 But if it is a separate program,
986 then the missing parts can still be accessed at the backend directly. 997 then the missing parts can still be accessed at the backend directly.
987 If it is integrated, then this will hardly be possible. 998 If it is integrated, then this will hardly be possible.
988 Further more, it is possible to have different frontends to the same 999 An additional advantage is the possibility to have different frontends
989 backend. 1000 to the same backend.
990 1001
991 .PP 1002 .PP
992 .B "Choose portability over efficiency 1003 .B "Choose portability over efficiency
993 and 1004 and
994 .B "use shell scripts to increase leverage and portability" . 1005 .B "use shell scripts to increase leverage and portability" .
996 Bolsky and Korn in their book about the Korn Shell. 1007 Bolsky and Korn in their book about the Korn Shell.
997 .[ 1008 .[
998 bolsky korn 1009 bolsky korn
999 korn shell 1010 korn shell
1000 .] 1011 .]
1001 They demonstrated, in chapter 18 of the book, a basic implementation 1012 Chapter\|18 of the book shows a basic implementation
1002 of a subset of \s-1MH\s0 in ksh scripts. 1013 of a subset of \s-1MH\s0 in ksh scripts.
1003 Of course, this was just a demonstration, but a brilliant one. 1014 Of course, this is just a demonstration, but a brilliant one.
1004 It shows how quickly one can implement such a prototype with shell scripts, 1015 It shows how quickly one can implement such a prototype with shell scripts,
1005 and how readable they are. 1016 and how readable they are.
1006 The implementation in the scripting language may not be very fast, 1017 The implementation in the scripting language may not be very fast,
1007 but it can be fast enough though, and this is all that matters. 1018 but it can be fast enough though, and this is all that matters.
1008 By having the code in an interpreted language, like the shell, 1019 By having the code in an interpreted language, like the shell,
1009 portability becomes a minor issue, if we assume the interpreter 1020 portability becomes a minor issue, if we assume the interpreter
1010 to be widespread. 1021 to be widespread.
1022 .PP
1011 This demonstration also shows how easy it is to create single programs 1023 This demonstration also shows how easy it is to create single programs
1012 of a toolchest software. 1024 of a toolchest software.
1013 There are eight tools (two of them have multiple names) and 16 functions 1025 Eight tools (two of them have multiple names) and 16 functions
1014 with supporting code. 1026 with supporting code are presented to the reader.
1015 Each tool comprises between 12 and 38 lines of ksh, 1027 The tools comprise less than 40 lines of ksh each,
1016 in total about 200 lines. 1028 in total about 200 lines.
1017 The functions comprise between 3 and 78 lines of ksh, 1029 The functions comprise less than 80 lines of ksh each,
1018 in total about 450 lines. 1030 in total about 450 lines.
1019 Such small software is easy to write, easy to understand, 1031 Such small software is easy to write, easy to understand,
1020 and thus easy to maintain. 1032 and thus easy to maintain.
1021 A toolchest improves the possibility to only write some parts 1033 A toolchest improves the possibility to only write some parts
1022 and though create a working result. 1034 and though create a working result.
1023 Expanding the toolchest without global changes will likely be 1035 Expanding the toolchest, even without global changes,
1024 possible, too. 1036 will likely be possible.
1025 1037
1026 .PP 1038 .PP
1027 .B "Use software leverage to your advantage 1039 .B "Use software leverage to your advantage
1028 and the lesser tenet 1040 and the lesser tenet
1029 .B "allow the user to tailor the environment 1041 .B "allow the user to tailor the environment
1030 are ideally followed in the design of \s-1MH\s0. 1042 are ideally followed in the design of \s-1MH\s0.
1031 Tailoring the environment is heavily encouraged by the ability to 1043 Tailoring the environment is heavily encouraged by the ability to
1032 directly define default options to programs. 1044 directly define default options to programs.
1033 It is even possible to define different default options 1045 It is even possible to define different default options
1034 depending on the name under which the program was called. 1046 depending on the name under which a program is called.
1035 Software leverage is heavily encouraged by the ease it is to 1047 Software leverage is heavily encouraged by the ease of
1036 create shell scripts that run a specific command line, 1048 creating shell scripts that run a specific command line,
1037 built of several \s-1MH\s0 programs. 1049 built of several \s-1MH\s0 programs.
1038 There is few software that so much wants users to tailor their 1050 There is few software that so much wants users to tailor their
1039 environment and to leverage the use of the software, like \s-1MH\s0. 1051 environment and to leverage the use of the software, like \s-1MH\s0.
1052 .PP
1040 Just to make one example: 1053 Just to make one example:
1041 One might prefer a different listing format for the \f(CWscan\fP 1054 One might prefer a different listing format for the \f(CWscan\fP
1042 program. 1055 program.
1043 It is possible to take one of the distributed format files 1056 It is possible to take one of the distributed format files
1044 or to write one yourself. 1057 or to write one yourself.
1051 must be added to \f(CW.mh_profile\fP. 1064 must be added to \f(CW.mh_profile\fP.
1052 If one wants this different format as an additional command, 1065 If one wants this different format as an additional command,
1053 instead of changing the default, he needs to create a link to 1066 instead of changing the default, he needs to create a link to
1054 \f(CWscan\fP, for instance titled \f(CWscan2\fP. 1067 \f(CWscan\fP, for instance titled \f(CWscan2\fP.
1055 The line in \f(CW.mh_profile\fP would then start with \f(CWscan2\fP, 1068 The line in \f(CW.mh_profile\fP would then start with \f(CWscan2\fP,
1056 as the option should only be in effect when scan is called as 1069 as the option should only be in effect for a program that is called as
1057 \f(CWscan2\fP. 1070 \f(CWscan2\fP.
1058 1071
1059 .PP 1072 .PP
1060 .B "Make every program a filter 1073 .B "Make every program a filter
1061 is hard to find in \s-1MH\s0. 1074 is hard to find in \s-1MH\s0.
1062 The reason therefore is that most of \s-1MH\s0's tools provide 1075 The reason therefore is that most of \s-1MH\s0's tools provide
1063 basic file system operations for the mailboxes. 1076 basic file system operations for mailboxes.
1064 The reason is the same because of which 1077 It is the same reason because of which \f(CWls\fP, \f(CWcp\fP, \f(CWmv\fP,
1065 \f(CWls\fP, \f(CWcp\fP, \f(CWmv\fP, and \f(CWrm\fP 1078 and \f(CWrm\fP aren't filters neither.
1066 aren't filters neither.
1067 However, they build a basis on which filters can operate.
1068 \s-1MH\s0 does not provide many filters itself, but it is a basis 1079 \s-1MH\s0 does not provide many filters itself, but it is a basis
1069 to write filters for. 1080 to write filters for.
1070 An example would be a mail message text highlighter, 1081 An example would be a mail text highlighter,
1071 that means a program that makes use of a color terminal to display 1082 that means a program that makes use of a color terminal to display
1072 header lines, quotations, and signatures in distinct colors. 1083 header lines, quotations, and signatures in distinct colors.
1073 The author's version of this program, for instance, 1084 The author's version of such a program is an awk script with 25 lines.
1074 is a 25 line awk script.
1075 1085
1076 .PP 1086 .PP
1077 .B "Build a prototype as soon as possible 1087 .B "Build a prototype as soon as possible
1078 was again well followed by \s-1MH\s0. 1088 was again well followed by \s-1MH\s0.
1079 This tenet, of course, focuses on early development, which is 1089 This tenet, of course, focuses on early development, which is
1085 .[ 1095 .[
1086 ware rand history 1096 ware rand history
1087 %P 132 1097 %P 132
1088 .] 1098 .]
1089 .QP 1099 .QP
1090 .ps -1 1100 [...] but [Stockton Gaines and Norm Shapiro] were not able
1091 [...] but they [Stockton Gaines and Norm Shapiro] were not able
1092 to convince anyone that such a system would be fast enough to be usable. 1101 to convince anyone that such a system would be fast enough to be usable.
1093 I proposed a very short project to prove the basic concepts, 1102 I proposed a very short project to prove the basic concepts,
1094 and my management agreed. 1103 and my management agreed.
1095 Looking back, I realize that I had been very lucky with my first design. 1104 Looking back, I realize that I had been very lucky with my first design.
1096 Without nearly enough design work, 1105 Without nearly enough design work,
1105 Problems 1114 Problems
1106 .XS 1115 .XS
1107 \*(SN Problems 1116 \*(SN Problems
1108 .XE 1117 .XE
1109 .LP 1118 .LP
1110 \s-1MH\s0, for sure is not without problems. 1119 \s-1MH\s0 is not without problems.
1111 There are two main problems: one is technical, the other is about human behavior. 1120 There are two main problems: one is technical, the other is about human behavior.
1112 .PP 1121 .PP
1113 \s-1MH\s0 is old and email today is very different to email in the time 1122 \s-1MH\s0 is old and email today is very different to email in the time
1114 when \s-1MH\s0 was designed. 1123 when \s-1MH\s0 was designed.
1115 \s-1MH\s0 adopted to the changes pretty well, but it is limited. 1124 \s-1MH\s0 adapted to the changes pretty well, but it is limited, though.
1116 For example in development resources.
1117 \s-1MIME\s0 support and support for different character encodings 1125 \s-1MIME\s0 support and support for different character encodings
1118 is available, but only on a moderate level. 1126 is available, but only on a moderate level.
1119 More active developers could quickly improve there. 1127 This comes from limited development resources.
1120 It is also limited by design, which is the larger problem. 1128 More active developers could quickly change this.
1129 But \s-1MH\s0 is also limited by design, which is the larger problem.
1121 \s-1IMAP\s0, for example, conflicts with \s-1MH\s0's design to a large extend. 1130 \s-1IMAP\s0, for example, conflicts with \s-1MH\s0's design to a large extend.
1122 These design conflicts are not easily solvable. 1131 These design conflicts are not easily solvable.
1123 Possibly, they require a redesign. 1132 Possibly, they require a redesign.
1124 Maybe \s-1IMAP\s0 is too different to the classic mail model which \s-1MH\s0 covers, 1133 \s-1IMAP\s0 may be too different to the classic mail model,
1125 hence \s-1MH\s0 may never work well with \s-1IMAP\s0. 1134 which \s-1MH\s0 covers, so that \s-1MH\s0 may never support it well.
1126 .PP 1135 .PP
1127 The other kind of problem is human habits. 1136 The other kind of problem are human habits.
1128 When in this world almost all \s-1MUA\s0s are monolithic, 1137 In this world, where almost all \s-1MUA\s0s are monolithic,
1129 it is very difficult to convince people to use a toolbox style \s-1MUA\s0 1138 it is very difficult to convince people to use a toolbox style \s-1MUA\s0
1130 like \s-1MH\s0. 1139 like \s-1MH\s0.
1131 The habits are so strong, that even people who understood the concept 1140 The habits are so strong, that even people who understand the concept
1132 and advantages of \s-1MH\s0 do not like to switch, 1141 and advantages of \s-1MH\s0 do not like to switch,
1133 simply because \s-1MH\s0 is different. 1142 simply because \s-1MH\s0 is different.
1134 Unfortunately, the frontends to \s-1MH\s0, which could provide familiar look'n'feel, 1143 Unfortunately, the frontends to \s-1MH\s0, which could provide familiar look'n'feel,
1135 are quite outdated and thus not very appealing compared to the modern interfaces 1144 are quite outdated and thus not very appealing, compared to the modern interfaces
1136 which monolithic \s-1MUA\s0s offer. 1145 of many monolithic \s-1MUA\s0s.
1137 1146
1138 .NH 2 1147 .NH 2
1139 Summary \s-1MH\s0 1148 Summary \s-1MH\s0
1140 .XS 1149 .XS
1141 \*(SN Summary \s-1MH\s0 1150 \*(SN Summary \s-1MH\s0
1142 .XE 1151 .XE
1143 .LP 1152 .LP
1144 \s-1MH\s0 is an \s-1MUA\s0 that follows the Unix Philosophy in its design 1153 \s-1MH\s0 is an \s-1MUA\s0 that follows the Unix Philosophy in its design.
1145 and implementation.
1146 It consists of a toolchest of small tools, each of them does one job well. 1154 It consists of a toolchest of small tools, each of them does one job well.
1147 The tools are orthogonal to each other, to a large extend.
1148 However, for historical reasons, there also exist distinct tools
1149 that cover the same task.
1150 .PP
1151 The toolchest approach offers great flexibility to the user. 1155 The toolchest approach offers great flexibility to the user.
1152 He can use the complete power of the Unix shell with \s-1MH\s0. 1156 It is possible to utilize the complete power of the Unix shell with \s-1MH\s0.
1153 This makes \s-1MH\s0 a very powerful mail system. 1157 This makes \s-1MH\s0 a very powerful mail system.
1154 Extending and customizing \s-1MH\s0 is easy and encouraged, too. 1158 Extending and customizing \s-1MH\s0 is easy and encouraged.
1155 .PP 1159 .PP
1156 Apart from the user's perspective, \s-1MH\s0 is development-friendly. 1160 Apart from the user's perspective, \s-1MH\s0 is development-friendly.
1157 Its overall design follows clear rules. 1161 Its overall design follows clear rules.
1158 The single tools do only one job, thus they are easy to understand, 1162 The single tools do only one job, thus they are easy to understand,
1159 easy to write, and good to maintain. 1163 easy to write, and good to maintain.
1173 .sp .5v 1177 .sp .5v
1174 \*(SN Case study: uzbl 1178 \*(SN Case study: uzbl
1175 .XE 1179 .XE
1176 .LP 1180 .LP
1177 The last chapter took a look on the \s-1MUA\s0 \s-1MH\s0, 1181 The last chapter took a look on the \s-1MUA\s0 \s-1MH\s0,
1178 this chapter is about uzbl, a web browser that adheres to the Unix Philosophy. 1182 which is an old and established software.
1179 ``uzbl'' is the \fIlolcat\fP's word for the English adjective ``usable''. 1183 This chapter covers uzbl, a fresh new project.
1180 It is pronounced the identical. 1184 Uzbl is a web browser that adheres to the Unix Philosophy.
1185 Its name comes from the \fILolspeak\fP word for ``usable'';
1186 it is pronounced identical.
1181 1187
1182 .NH 2 1188 .NH 2
1183 Historical background 1189 Historical background
1184 .XS 1190 .XS
1185 \*(SN Historical background 1191 \*(SN Historical background
1201 Fortunately, he found the time. 1207 Fortunately, he found the time.
1202 One day later, the first prototype was out. 1208 One day later, the first prototype was out.
1203 One week later, uzbl had an own website. 1209 One week later, uzbl had an own website.
1204 One month after the first code showed up, 1210 One month after the first code showed up,
1205 a mailing list was installed to coordinate and discuss further development. 1211 a mailing list was installed to coordinate and discuss further development.
1206 A wiki was set up to store documentation and scripts that showed up on the 1212 Then a wiki followed to store documentation and scripts that showed up on the
1207 mailing list and elsewhere. 1213 mailing list and elsewhere.
1208 .PP 1214 .PP
1209 In the, now, one year of uzbl's existence, it was heavily developed in various branches. 1215 In the, now, one year of uzbl's existence, it was heavily developed on various branches.
1210 Plaetinck's task became more and more to only merge the best code from the 1216 Plaetinck's task became more and more to only merge the best code from the
1211 different branches into his main branch, and to apply patches. 1217 different branches into his main branch, and to apply patches.
1212 About once a month, Plaetinck released a new version. 1218 About once a month, Plaetinck released a new version.
1213 In September 2009, he presented several forks of uzbl. 1219 In September 2009, he presented several forks of uzbl.
1214 Uzbl, actually, opened the field for a whole family of web browsers with similar shape. 1220 Uzbl, actually, opened the field for a whole family of web browsers with similar shape.
1226 most web browsers are monolithic, but uzbl is a frontend to a toolchest. 1232 most web browsers are monolithic, but uzbl is a frontend to a toolchest.
1227 .PP 1233 .PP
1228 Today, uzbl is divided into uzbl-core and uzbl-browser. 1234 Today, uzbl is divided into uzbl-core and uzbl-browser.
1229 Uzbl-core is, how its name already indicates, the core of uzbl. 1235 Uzbl-core is, how its name already indicates, the core of uzbl.
1230 It handles commands and events to interface other programs, 1236 It handles commands and events to interface other programs,
1231 and also displays webpages by using webkit as render engine. 1237 and also displays webpages by using \fIwebkit\fP as render engine.
1232 Uzbl-browser combines uzbl-core with a bunch of handler scripts, a status bar, 1238 Uzbl-browser combines uzbl-core with a bunch of handler scripts, a status bar,
1233 an event manager, yanking, pasting, page searching, zooming, and more stuff, 1239 an event manager, yanking, pasting, page searching, zooming, and more stuff,
1234 to form a ``complete'' web browser. 1240 to form a ``complete'' web browser.
1235 In the following text, the term ``uzbl'' usually stands for uzbl-browser, 1241 In the following text, the term ``uzbl'' usually stands for uzbl-browser,
1236 so uzbl-core is included. 1242 so uzbl-core is included.
1237 .PP 1243 .PP
1238 Unlike most other web browsers, uzbl is mainly the mediator between the 1244 Unlike most other web browsers, uzbl is mainly the mediator between the
1239 various tools that cover single jobs of web browsing. 1245 various tools that cover single jobs.
1240 Therefore, uzbl listens for commands on a named pipe (fifo), a Unix socket, 1246 Therefore, uzbl listens for commands on a named pipe (fifo), a Unix socket,
1241 and on stdin, and it writes events to a Unix socket and to stdout. 1247 and on stdin, and it writes events to a Unix socket and to stdout.
1242 The graphical rendering of the webpage is done by webkit, a web content engine.
1243 Uzbl-core is build around this library.
1244 Loading a webpage in a running uzbl instance requires only: 1248 Loading a webpage in a running uzbl instance requires only:
1245 .DS 1249 .DS
1246 .CW 1250 .CW
1247 echo 'uri http://example.org' >/path/to/uzbl-fifo 1251 echo 'uri http://example.org' >/path/to/uzbl-fifo
1248 .DE 1252 .DE
1249 .PP 1253 The graphical rendering of the webpage is done by webkit,
1250 Downloads, browsing history, bookmarks, and thelike are not provided 1254 a web content engine.
1251 by uzbl-core itself, as they are in other web browsers. 1255 Uzbl-core is built around libwebkit.
1256 .PP
1257 Downloads, browsing history, bookmarks, and the like are not provided
1258 by the core itself, like they are in other web browsers.
1252 Uzbl-browser also only provides, so called, handler scripts that wrap 1259 Uzbl-browser also only provides, so called, handler scripts that wrap
1253 external applications which provide the actual functionality. 1260 external applications which provide the actual functionality.
1254 For instance, \fIwget\fP is used to download files and uzbl-browser 1261 For instance, \fIwget\fP is used to download files and uzbl-browser
1255 includes a script that calls wget with appropriate options in 1262 includes a script that calls wget with appropriate options in
1256 a prepared environment. 1263 a prepared environment.
1257 .PP 1264 .PP
1258 Modern web browsers are proud to have addons, plugins, and modules, instead. 1265 Modern web browsers are proud to have addons, plugins, and modules, instead.
1259 This is their effort to achieve similar goals. 1266 This is their effort to achieve similar goals.
1260 But instead of using existing, external programs, modern web browsers 1267 But instead of using existing, external programs, modern web browsers
1261 include these functions, although they might be loaded at runtime. 1268 include these functions.
1262 1269
1263 .NH 2 1270 .NH 2
1264 Discussion of the design 1271 Discussion of the design
1265 .XS 1272 .XS
1266 \*(SN Discussion of the design 1273 \*(SN Discussion of the design
1273 .B "Make each program do one thing well" . 1280 .B "Make each program do one thing well" .
1274 Uzbl tries to be a web browser and nothing else. 1281 Uzbl tries to be a web browser and nothing else.
1275 The common definition of a web browser is, of course, highly influenced by 1282 The common definition of a web browser is, of course, highly influenced by
1276 existing implementations of web browsers, although they are degenerated. 1283 existing implementations of web browsers, although they are degenerated.
1277 Web browsers should be programs to browse the web, and nothing more. 1284 Web browsers should be programs to browse the web, and nothing more.
1278 This is the one thing they should do, as demanded by the Unix Philosophy. 1285 This is the one thing they should do.
1279 .PP 1286 .PP
1280 Web browsers should, for instance, not manage downloads. 1287 Web browsers should not, for instance, manage downloads.
1281 This is the job download managers exist for. 1288 This is the job download managers exist for.
1282 Download managers do primary care about being good in downloading files. 1289 Download managers do primary care about being good in downloading files.
1283 Modern web browsers provide download management only as a secondary feature. 1290 Modern web browsers provide download management only as a secondary feature.
1284 How could they perform this job better, than programs that exist only for 1291 How could they do this job better, than programs that exist only for
1285 this very job? 1292 this very job?
1286 And how could anyone want less than the best download manager available? 1293 And how could anyone want less than the best download manager available?
1287 .PP 1294 .PP
1288 A web browser's job is to let the user browse the web. 1295 A web browser's job is to let the user browse the web.
1289 This means, navigating through websites by following links. 1296 This means, navigating through websites by following links.
1304 The lesser tenet 1311 The lesser tenet
1305 .B "allow the user to tailor the environment 1312 .B "allow the user to tailor the environment
1306 matches good here. 1313 matches good here.
1307 There was the question, how anyone could want anything less than the 1314 There was the question, how anyone could want anything less than the
1308 best program for the job. 1315 best program for the job.
1309 But as personal preferences matter much, 1316 But as personal preferences matter, it is probably more important to ask:
1310 it is probably more important to ask:
1311 How could anyone want something else than his preferred program for the job? 1317 How could anyone want something else than his preferred program for the job?
1312 .PP 1318 .PP
1313 Usually users want one program for one job. 1319 Usually users want one program for a specific job.
1314 Hence, whenever the task is, for instance, downloading, 1320 Hence, whenever the task is, for instance, downloading,
1315 exactly one download manager should be used. 1321 the same download manager should be used.
1316 More advanced users might want to have this download manager in this 1322 More advanced users might want to have this download manager in this
1317 situation and that one in that situation. 1323 situation and that one in that situation.
1318 They should be able to configure it this way. 1324 They should be able to configure it this way.
1319 With uzbl, one can use any download manager the user wants. 1325 With uzbl, one can use any download manager the user wants.
1320 To switch to a different one, only one line in a small handler script 1326 To switch to a different one, only one line in a small handler script
1321 needs to be changed. 1327 needs to be changed.
1322 Alternatively it would be possible to query an entry in a global file 1328 Alternatively it would be possible to query the program to use by
1323 or an environment variable, which specifies the download manager to use, 1329 reading a global file or an environment variable, in the handler script.
1324 in the handler script. 1330 .PP
1325 .PP 1331 Uzbl does neither have its own download manager nor depends on a
1326 As uzbl does neither have its own download manager nor depends on a 1332 specific one, hence uzbl's browsing abilities will not be lowered by having
1327 specific one, thus uzbl's browsing abilities will not be lowered by having
1328 a bad download manager. 1333 a bad download manager.
1329 Uzbl's download capabilities will just as good as the ones of the best 1334 Uzbl's download capabilities will be just as good as the ones of the best
1330 download manager available on the system. 1335 download manager available on the system.
1331 Of course, this applies to all of the other supplementary tools, too. 1336 Of course, this applies to all of the other supplementary tools, too.
1332 1337
1333 .PP 1338 .PP
1334 .B "Use software leverage to your advantage" . 1339 .B "Use software leverage to your advantage" .
1335 Shell scripts are a good choice to extend uzbl.
1336 Uzbl is designed to be extended by external tools. 1340 Uzbl is designed to be extended by external tools.
1337 These external tools are usually wrapped by small handler shell scripts. 1341 These external tools are usually wrapped by small handler shell scripts.
1338 Shell scripts are the glue in this approach. 1342 Shell scripts are the glue in this approach.
1339 They make the various parts fit together. 1343 They make the various parts fit together.
1340 .PP 1344 .PP
1341 As an example, the history mechanism of uzbl shall be presented. 1345 The history mechanism of uzbl shall be presented as an example.
1342 Uzbl is configured to spawn a script to append an entry to the history 1346 Uzbl is configured to spawn a script to append an entry to the history
1343 whenever the event of a fully loaded page occurs. 1347 whenever the event of a fully loaded page occurs.
1344 The script to append the entry to the history not much more than: 1348 The script to append the entry to the history is not much more than:
1345 .DS 1349 .DS
1346 .CW 1350 .CW
1347 #!/bin/sh 1351 #!/bin/sh
1348 file=/path/to/uzbl-history 1352 file=/path/to/uzbl-history
1349 echo `date +'%Y-%m-%d %H:%M:%S'`" $6 $7" >> $file 1353 echo `date +'%Y-%m-%d %H:%M:%S'`" $6 $7" >> $file
1350 .DE 1354 .DE
1351 \f(CW$6\fP and \f(CW$7\fP expand to the \s-1URL\s0 and the page title. 1355 \f(CW$6\fP and \f(CW$7\fP expand to the \s-1URL\s0 and the page title.
1352 For loading an entry, a key is bound to spawn a load from history script. 1356 .PP
1357 For loading an entry, a key is bound to spawn a load-from-history script.
1353 The script reverses the history to have newer entries first, 1358 The script reverses the history to have newer entries first,
1354 then displays \fIdmenu\fP to select an item, 1359 then displays \fIdmenu\fP to let the user select an item,
1355 and afterwards writes the selected \s-1URL\s0 into uzbl's command input pipe. 1360 and afterwards writes the selected \s-1URL\s0 into uzbl's command input pipe.
1356 With error checking and corner cases removed, the script looks like this: 1361 With error checking and corner case handling removed,
1362 the script looks like this:
1357 .DS 1363 .DS
1358 .CW 1364 .CW
1359 #!/bin/sh 1365 #!/bin/sh
1360 file=/path/to/uzbl-history 1366 file=/path/to/uzbl-history
1361 goto=`tac $file | dmenu | cut -d' ' -f 3` 1367 goto=`tac $file | dmenu | cut -d' ' -f 3`
1367 .PP 1373 .PP
1368 .B "Avoid captive user interfaces" . 1374 .B "Avoid captive user interfaces" .
1369 One could say, that uzbl, to a large extend, actually \fIis\fP 1375 One could say, that uzbl, to a large extend, actually \fIis\fP
1370 a captive user interface. 1376 a captive user interface.
1371 But the difference to most other web browsers is, that uzbl is only 1377 But the difference to most other web browsers is, that uzbl is only
1372 the captive user interface frontend and the core of the backend. 1378 the captive user interface frontend (and the core of the backend).
1373 Many parts of the backend are independent of uzbl. 1379 Many parts of the backend are independent of uzbl.
1374 Some are distributed with uzbl, for some external programs, handler scripts 1380 Some are distributed with uzbl, for some external programs,
1375 are distributed, arbitrary additional functionality can be added if desired. 1381 handler scripts are distributed,
1382 but arbitrary additional functionality can be added if desired.
1376 .PP 1383 .PP
1377 The frontend is captive \(en that is true. 1384 The frontend is captive \(en that is true.
1378 This is okay for the task of browsing the web, as this task is only relevant 1385 This is okay for the task of browsing the web, as this task is only relevant
1379 for humans. 1386 for humans.
1380 Automated programs would \fIcrawl\fP the web. 1387 Automated programs would \fIcrawl\fP the web.
1385 1392
1386 .PP 1393 .PP
1387 .B "Make every program a filter" . 1394 .B "Make every program a filter" .
1388 Graphical web browsers are almost dead ends in the chain of information flow. 1395 Graphical web browsers are almost dead ends in the chain of information flow.
1389 Thus it is difficult to see what graphical web browsers should filter. 1396 Thus it is difficult to see what graphical web browsers should filter.
1390 Graphical web browsers exist almost only for interactive use by humans. 1397 Graphical web browsers exist almost only to be interactively used by humans.
1391 The only case when one might want to automate the rendering function is 1398 The only case when one might want to automate the rendering function is
1392 to generate images of rendered webpages. 1399 to generate images of rendered webpages.
1393 1400
1394 .PP 1401 .PP
1395 .B "Small is beautiful" 1402 .B "Small is beautiful"
1396 is not easy to apply to a web browser, primary because modern web technology 1403 is not easy to apply to a web browser, because modern web technology
1397 is very complex; hence the rendering task is very complex. 1404 is very complex, hence the rendering task is very complex.
1398 Modern web browsers will always consist of many thousand lines of code, 1405 Modern web browsers have to consist of many thousand lines of code,
1399 unfortunately. 1406 unfortunately.
1400 Using the toolchest approach and wrappers can split the browser into 1407 Using the toolchest approach and wrappers can split the browser into
1401 several small parts, tough. 1408 several small parts, tough.
1402 .PP 1409 .PP
1403 Uzbl-core consists of about 3\,500 lines of C code. 1410 As of March 2010, uzbl-core consists of about 3\,500 lines of C code.
1404 The distribution includes another 3\,500 lines of Shell and Python code, 1411 The distribution includes another 3\,500 lines of Shell and Python code,
1405 which are the handler scripts and plugins like a modal interface. 1412 which are the handler scripts and plugins like a modal interface.
1406 Further more, uzbl uses functionality of external tools like 1413 Further more, uzbl uses functionality of external tools like
1407 \fIwget\fP and \fInetcat\fP. 1414 \fIwget\fP and \fInetcat\fP.
1408 Up to this point, uzbl looks pretty neat and small. 1415 Up to this point, uzbl looks pretty neat and small.
1409 The ugly part of uzbl is the web content renderer, webkit. 1416 The ugly part of uzbl is the web content renderer, webkit.
1410 Webkit consists of roughly 400\,000 (!) lines of code. 1417 Webkit consists of roughly 400\,000 (!) lines of code.
1411 Unfortunately, small web render engines are not possible anymore 1418 Unfortunately, small web render engines are not possible anymore
1412 because of the modern web. 1419 because of the modern web.
1413 The problems section will explain this in more detail.
1414 1420
1415 .PP 1421 .PP
1416 .B "Build a prototype as soon as possible" . 1422 .B "Build a prototype as soon as possible" .
1417 Plaetinck made his code public, right from the beginning. 1423 Plaetinck made his code public, right from the beginning.
1418 Discussion and development was, and still is, open to everyone interested. 1424 Discussion and development was, and still is, open to everyone interested.
1419 Development versions of uzbl can be obtained very simply from the code 1425 Development versions of uzbl can be obtained very simply from the code
1420 repository. 1426 repository.
1421 Within the first year of uzbl's existence, a new version was released 1427 Within the first year of uzbl's existence, a new version was released
1422 more often than once a month. 1428 more often than once a month.
1423 Different forks and branches arose. 1429 Different forks and branches arose.
1424 They introduced new features, which were tested for suitability. 1430 They introduced new features, which were tested for suitability
1431 for the main branch.
1425 The experiences of using prototypes influenced further development. 1432 The experiences of using prototypes influenced further development.
1426 Actually, all development was community driven. 1433 Actually, all development was community driven.
1427 Plaetinck says, three months after uzbl's birth: 1434 Plaetinck says, three months after uzbl's birth:
1428 ``Right now I hardly code anything myself for Uzbl. 1435 ``Right now I hardly code anything myself for Uzbl.
1429 I just merge in other people's code, ponder a lot, and lead the discussions.'' 1436 I just merge in other people's code, ponder a lot, and lead the discussions.''
1445 same as the one of the well known web browsers, 1452 same as the one of the well known web browsers,
1446 hiding the internal differences. 1453 hiding the internal differences.
1447 But uzbl has to provide this similar look and feel to be accepted 1454 But uzbl has to provide this similar look and feel to be accepted
1448 as a ``normal'' browser by ``normal'' users. 1455 as a ``normal'' browser by ``normal'' users.
1449 .PP 1456 .PP
1450 The more important problem is the modern web. 1457 Though, the more important problem is the modern web.
1451 The modern web is simply broken. 1458 The modern web is simply broken.
1452 It has state in a state-less protocol, 1459 It has state in a state-less protocol,
1453 it misuses technologies, 1460 it misuses technologies,
1454 and it is helplessly overloaded. 1461 and it is helplessly overloaded.
1455 The result are web content render engines that must consist 1462 The result are web content render engines that must consist
1456 of hundreds of thousands lines of code. 1463 of hundreds of thousands lines of code.
1457 They also must combine and integrate many different technologies, 1464 They also must combine and integrate many different technologies,
1458 only to make our modern web usable. 1465 only to make our modern web accessible.
1459 Website to image converter are hardly possible to run without 1466 Website to image converter are hardly possible to run without
1460 human interaction because of state in sessions, impossible 1467 human interaction because of state in sessions, impossible
1461 deep-linking, and unautomatable technologies. 1468 deep-linking, and unautomatable technologies.
1462 .PP 1469 .PP
1463 The web was misused to provide all kinds of imaginable wishes. 1470 The web was misused to provide all kinds of imaginable wishes.
1472 .LP 1479 .LP
1473 ``Uzbl is a browser that adheres to the Unix Philosophy'', 1480 ``Uzbl is a browser that adheres to the Unix Philosophy'',
1474 that is how uzbl is seen by its authors. 1481 that is how uzbl is seen by its authors.
1475 Indeed, uzbl follows the Unix Philosophy in many ways. 1482 Indeed, uzbl follows the Unix Philosophy in many ways.
1476 It consists of independent parts that work together, 1483 It consists of independent parts that work together,
1477 its core is mainly a mediator which glues the parts together. 1484 while its core is mainly a mediator which glues the parts together.
1478 .PP 1485 .PP
1479 Software leverage can excellently be seen in uzbl. 1486 Software leverage can excellently be seen in uzbl.
1480 It makes use of external tools, separates independent tasks 1487 External tools are used, independent tasks are separated
1481 in independent parts, and glues them together with small 1488 in independent parts and glued together with small handler scripts.
1482 handler scripts, around uzbl-core.
1483 .PP 1489 .PP
1484 As uzbl, more or less, consists of a set of tools and a bit 1490 As uzbl, more or less, consists of a set of tools and a bit
1485 of glue, anyone can put the parts together and expand it 1491 of glue, anyone can put the parts together and expand it
1486 in any desired way. 1492 in any desired way.
1487 Uzbl is very flexible and customizable. 1493 Uzbl is very flexible and customizable.
1488 These properties make it valuable for advanced users, 1494 These properties make it valuable for advanced users,
1489 but may keep novice users from using it. 1495 but may keep novice users from using it.
1490 .PP 1496 .PP
1491 Uzbl's main problem is the modern web, that makes it hard 1497 But uzbl's main problem is the modern web, that makes it hard
1492 to design a sane web browser. 1498 to design a sane web browser.
1493 Despite this bad situation, uzbl does a fairly good job. 1499 Despite this bad situation, uzbl does a fairly good job.
1494 1500
1495 1501
1496 .NH 1 1502 .NH 1