view @ 40:422679bdf384

rework in ch01
date Thu, 08 Apr 2010 23:11:28 +0200
parents c87143793d82
children 13ef7042fa28
line source
1 .\".if n .pl 1000i
2 .nr PS 11
3 .nr VS 13
4 .de XX
5 .pl 1v
6 ..
7 .em XX
8 .\".nr PI 0
9 .\".if t .nr PD .5v
10 .\".if n .nr PD 1v
11 .nr lu 0
12 .de CW
13 .nr PQ \\n(.f
14 .if t .ft CW
15 .ie ^\\$1^^ .if n .ul 999
16 .el .if n .ul 1
17 .if t .if !^\\$1^^ \&\\$1\f\\n(PQ\\$2
18 .if n .if \\n(.$=1 \&\\$1
19 .if n .if \\n(.$>1 \&\\$1\c
20 .if n .if \\n(.$>1 \&\\$2
21 ..
22 .ds [. \ [
23 .ds .] ]
24 .\"----------------------------------------
25 .TL
26 Why the Unix Philosophy still matters
27 .AU
28 markus schnalke <>
29 .AB
30 .ti \n(.iu
31 This paper explains the importance of the Unix Philosophy for software design.
32 Today, few software designers are aware of these concepts,
33 and thus a lot of modern software is more limited than necessary
34 and makes less use of software leverage than possible.
35 Knowing and following the guidelines of the Unix Philosophy makes software more valuable.
36 .AE
38 .\".if t .2C
40 .FS
41 .ps -1
42 This paper was prepared for the ``Software Analysis'' seminar at University Ulm.
43 Mentor was professor Schweiggert. 2010-04-05
44 .br
45 You may retrieve this document from
46 .CW \s-1 \ .
47 .FE
49 .NH 1
50 Introduction
51 .LP
52 The Unix Philosophy is the essence of how the Unix operating system,
53 especially its toolchest, was designed.
54 It is no limited set of fixed rules,
55 but a loose set of guidelines which tell how to write software that
56 suites well into Unix.
57 Actually, the Unix Philosophy describes what is common to typical Unix software.
58 The Wikipedia has an accurate definition:
59 .[
60 %A Wikipedia
61 %T Unix philosophy
62 %P Wikipedia, The Free Encyclopedia
63 %D 2010-03-21 17:20 UTC
64 %O .CW \s-1
65 .]
66 .QP
67 The \fIUnix philosophy\fP is a set of cultural norms and philosophical
68 approaches to developing software based on the experience of leading
69 developers of the Unix operating system.
70 .PP
71 As there is no single definition of the Unix Philosophy,
72 several people have stated their view on what it comprises.
73 Best known are:
74 .IP \(bu
75 Doug McIlroy's summary: ``Write programs that do one thing and do it well.''
76 .[
77 %A M. D. McIlroy
78 %A E. N. Pinson
79 %A B. A. Taque
80 %T UNIX Time-Sharing System Forward
81 %J The Bell System Technical Journal
82 %D 1978
83 %V 57
84 %N 6
85 %P 1902
86 .]
87 .IP \(bu
88 Mike Gancarz' book ``The UNIX Philosophy''.
89 .[
90 %A Mike Gancarz
91 %T The UNIX Philosophy
92 %D 1995
93 %I Digital Press
94 .]
95 .IP \(bu
96 Eric S. Raymond's book ``The Art of UNIX Programming''.
97 .[
98 %A Eric S. Raymond
99 %T The Art of UNIX Programming
100 %D 2003
101 %I Addison-Wesley
102 %O .CW \s-1
103 .]
104 .LP
105 These different views on the Unix Philosophy have much in common.
106 Especially, the main concepts are similar in all of them.
107 McIlroy's definition can surely be called the core of the Unix Philosophy,
108 but the fundamental idea behind it all, is ``small is beautiful''.
110 .PP
111 The Unix Philosophy tells how to design and write good software for Unix.
112 Many concepts described here base on facilities of Unix.
113 Other operating systems may not offer such facilities,
114 hence it may not be possible to design software is the way of the Unix Philosophy.
118 This paper discusses the recommendations of the Unix Philosophy about software design.
119 .PP
120 The here discussed ideas can get applied by any development process.
121 The Unix Philosophy does recommend how the software development process should look like,
122 but this shall not be of matter here.
123 Similar, the question of how to write the code is out of focus.
124 .PP
125 Before we will have a look at concrete concepts,
126 we discuss why software design is important
127 and what problems bad design introduces.
130 .NH 1
131 Importance of software design in general
132 .LP
133 Software design is the planning of how the internal structure
134 and external interfaces of a software should look like.
135 It has nothing to do with visual appearance.
136 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,
138 the passenger/space ratio, the luggage capacity, and so forth.
139 .PP
140 Why should software get designed at all?
141 It is general knowledge, that even a bad plan is better than no plan.
142 Not designing software means programming without plan.
143 This will pretty sure lead to horrible results.
144 Horrible to use and horrible to maintain.
145 These two aspects are the visible ones.
146 Often invisible are the wasted possible gains.
147 Good software design can make these gains available.
148 .PP
149 A software's design deals with quality properties.
150 Good design leads to good quality, and quality is important.
151 Any car may be able to drive from A to B,
152 but it depends on the car's properties whether it is a good choice
153 for passenger transport or not.
154 It depends on its properties if it is a good choice
155 for a rough mountain area.
156 And it depends on its properties if the ride will be fun.
158 .PP
159 Requirements for a software are twofold:
160 functional and non-functional.
161 .IP \(bu
162 Functional requirements define directly the software's functions.
163 They are the reason why software gets written.
164 Someone has a problem and needs a tool to solve it.
165 Being able to solve the problem is the main functional goal.
166 It is the driving force behind all programming effort.
167 Functional requirements are easier to define and to verify.
168 .IP \(bu
169 Non-functional requirements are also called \fIquality\fP requirements.
170 The quality of a software are the properties that are not directly related to
171 the software's basic functions.
172 Tools of bad quality often solve the problems they were written for,
173 but introduce problems and difficulties for usage and development, later on.
174 Quality aspects are often overlooked at first sight,
175 and they are often difficult to define clearly and to verify.
176 .PP
177 Quality is of few matter when the software gets built initially,
178 but it is of matter for usage and maintenance of the software.
179 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
181 only a small amount of the overall work.
182 Bug fixing, extending, rebuilding of parts
183 \(en maintenance work, for short \(en
184 does soon take over the major part of the time spent on a software.
185 Not to forget the usage of the software.
186 These processes are highly influenced by the software's quality.
187 Thus, quality must not be neglected.
188 The problem with quality is that you hardly ``stumble over''
189 bad quality during the first build,
190 but this is the time when you should care about good quality most.
191 .PP
192 Software design is less the basic function of a software \(en
193 this requirement will get satisfied anyway.
194 Software design is more about quality aspects of the software.
195 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,
197 but good quality can provide a lot of additional gain,
198 even at places where one never expected it.
199 .PP
200 The ISO/IEC 9126-1 standard, part 1,
201 .[
202 %I International Organization for Standardization
203 %T ISO Standard 9126: Software Engineering \(en Product Quality, part 1
204 %C Geneve
205 %D 2001
206 .]
207 defines the quality model as consisting out of:
208 .IP \(bu
209 .I Functionality
210 (suitability, accuracy, inter\%operability, security)
211 .IP \(bu
212 .I Reliability
213 (maturity, fault tolerance, recoverability)
214 .IP \(bu
215 .I Usability
216 (understandability, learnability, operability, attractiveness)
217 .IP \(bu
218 .I Efficiency
219 (time behavior, resource utilization)
220 .IP \(bu
221 .I Maintainability
222 (analyzability, changeability, stability, testability)
223 .IP \(bu
224 .I Portability
225 (adaptability, installability, co-existence, replaceability)
226 .LP
227 Good design can improve these properties of a software,
228 bad designed software probably suffers from not having them.
229 .PP
230 One further goal of software design is consistency.
231 Consistency eases understanding, working on, and using things.
232 Consistent internal structure and consistent interfaces to the outside
233 can be provided by good design.
234 .PP
235 Software should be well designed because good design avoids many
236 problems during the software's lifetime.
237 And software should be well designed because good design can offer
238 much additional gain.
239 Indeed, much effort should be spent into good design to make software more valuable.
240 The Unix Philosophy shows a way of how to design software well.
241 It offers guidelines to achieve good quality and high gain for the effort spent.
244 .NH 1
245 The Unix Philosophy
246 .LP
247 The origins of the Unix Philosophy were already introduced.
248 This chapter explains the philosophy, oriented on Gancarz,
249 and shows concrete examples of its application.
251 .NH 2
252 Pipes
253 .LP
254 Following are some examples to demonstrate how applied Unix Philosophy feels like.
255 Knowledge of using the Unix shell is assumed.
256 .PP
257 Counting the number of files in the current directory:
258 .DS I 2n
259 .CW
260 .ps -1
261 ls | wc -l
262 .DE
263 The
264 .CW ls
265 command lists all files in the current directory, one per line,
266 and
267 .CW "wc -l
268 counts the number of lines.
269 .PP
270 Counting the number of files that do not contain ``foo'' in their name:
271 .DS I 2n
272 .CW
273 .ps -1
274 ls | grep -v foo | wc -l
275 .DE
276 Here, the list of files is filtered by
277 .CW grep
278 to remove all that contain ``foo''.
279 The rest is the same as in the previous example.
280 .PP
281 Finding the five largest entries in the current directory.
282 .DS I 2n
283 .CW
284 .ps -1
285 du -s * | sort -nr | sed 5q
286 .DE
287 .CW "du -s *
288 returns the recursively summed sizes of all files
289 \(en no matter if they are regular files or directories.
290 .CW "sort -nr
291 sorts the list numerically in reverse order.
292 Finally,
293 .CW "sed 5q
294 quits after it has printed the fifth line.
295 .PP
296 The presented command lines are examples of what Unix people would use
297 to get the desired output.
298 There are also other ways to get the same output.
299 It's a user's decision which way to go.
300 .PP
301 The examples show that many tasks on a Unix system
302 are accomplished by combining several small programs.
303 The connection between the single programs is denoted by the pipe operator `|'.
304 .PP
305 Pipes, and their extensive and easy use, are one of the great
306 achievements of the Unix system.
307 Pipes between programs have been possible in earlier operating systems,
308 but it has never been a so central part of the concept.
309 When, in the early seventies, Doug McIlroy introduced pipes for the
310 Unix system,
311 ``it was this concept and notation for linking several programs together
312 that transformed Unix from a basic file-sharing system to an entirely new way of computing.''
313 .[
314 %T Unix: An Oral History
315 %O .CW \s-1
316 .]
317 .PP
318 Being able to specify pipelines in an easy way is,
319 however, not enough by itself.
320 It is only one half.
321 The other is the design of the programs that are used in the pipeline.
322 They have to interfaces that allows them to be used in such a way.
324 .NH 2
325 Interface design
326 .LP
327 Unix is, first of all, simple \(en Everything is a file.
328 Files are sequences of bytes, without any special structure.
329 Programs should be filters, which read a stream of bytes from ``standard input'' (stdin)
330 and write a stream of bytes to ``standard output'' (stdout).
331 .PP
332 If the files \fIare\fP sequences of bytes,
333 and the programs \fIare\fP filters on byte streams,
334 then there is exactly one standardized data interface.
335 Thus it is possible to combine them in any desired way.
336 .PP
337 Even a handful of small programs will yield a large set of combinations,
338 and thus a large set of different functions.
339 This is leverage!
340 If the programs are orthogonal to each other \(en the best case \(en
341 then the set of different functions is greatest.
342 .PP
343 Programs might also have a separate control interface,
344 besides their data interface.
345 The control interface is often called ``user interface'',
346 because it is usually designed to be used by humans.
347 The Unix Philosophy discourages to assume the user to be human.
348 Interactive use of software is slow use of software,
349 because the program waits for user input most of the time.
350 Interactive software requires the user to be in front of the computer
351 all the time.
352 Interactive software occupy the user's attention while they are running.
353 .PP
354 Now we come back to the idea of using several small programs, combined,
355 to have a more specific function.
356 If these single tools would all be interactive,
357 how would the user control them?
358 It is not only a problem to control several programs at once if they run at the same time,
359 it also very inefficient to have to control each of the single programs
360 that are intended to work as one large program.
361 Hence, the Unix Philosophy discourages programs to demand interactive use.
362 The behavior of programs should be defined at invocation.
363 This is done by specifying arguments (``command line switches'') to the program call.
364 Gancarz discusses this topic as ``avoid captive user interfaces''.
365 .[
366 %A Mike Gancarz
367 %T The UNIX Philosophy
368 %I Digital Press
369 %D 1995
370 %P 88 ff.
371 .]
372 .PP
373 Non-interactive use is, during development, also an advantage for testing.
374 Testing of interactive programs is much more complicated,
375 than testing of non-interactive programs.
377 .NH 2
378 The toolchest approach
379 .LP
380 A toolchest is a set of tools.
381 Instead of having one big tool for all tasks, one has many small tools,
382 each for one task.
383 Difficult tasks are solved by combining several of the small, simple tools.
384 .PP
385 The Unix toolchest \fIis\fP a set of small, (mostly) non-interactive programs
386 that are filters on byte streams.
387 They are, to a large extend, unrelated in their function.
388 Hence, the Unix toolchest provides a large set of functions
389 that can be accessed by combining the programs in the desired way.
390 .PP
391 There are also advantages for developing small toolchest programs.
392 It is easier and less error-prone to write small programs.
393 It is also easier and less error-prone to write a large set of small programs,
394 than to write one large program with all the functionality included.
395 If the small programs are combinable, then they offer even a larger set
396 of functions than the single large program.
397 Hence, one gets two advantages out of writing small, combinable programs.
398 .PP
399 There are two drawbacks of the toolchest approach.
400 First, one simple, standardized, unidirectional interface has to be sufficient.
401 If one feels the need for more ``logic'' than a stream of bytes,
402 then a different approach might be of need.
403 But it is also possible, that he just can not imagine a design where
404 a stream of bytes is sufficient.
405 By becoming more familiar with the ``Unix style of thinking'',
406 developers will more often and easier find simple designs where
407 a stream of bytes is a sufficient interface.
408 .PP
409 The second drawback of a toolchest affects the users.
410 A toolchest is often more difficult to use for novices.
411 It is necessary to become familiar with each of the tools,
412 to be able to use the right one in a given situation.
413 Additionally, one needs to combine the tools in a senseful way on its own.
414 This is like a sharp knife \(en it is a powerful tool in the hand of a master,
415 but of no good value in the hand of an unskilled.
416 .PP
417 However, learning single, small tool of the toolchest is easier than
418 learning a complex tool.
419 The user will have a basic understanding of a yet unknown tool,
420 if the several tools of the toolchest have a common style.
421 He will be able to transfer knowledge over one tool to another.
422 .PP
423 Moreover, the second drawback can be removed easily by adding wrappers
424 around the single tools.
425 Novice users do not need to learn several tools if a professional wraps
426 the single commands into a more high-level script.
427 Note that the wrapper script still calls the small tools;
428 the wrapper script is just like a skin around.
429 No complexity is added this way,
430 but new programs can get created out of existing one with very low effort.
431 .PP
432 A wrapper script for finding the five largest entries in the current directory
433 could look like this:
434 .DS I 2n
435 .CW
436 .ps -1
437 #!/bin/sh
438 du -s * | sort -nr | sed 5q
439 .DE
440 The script itself is just a text file that calls the command line
441 a professional user would type in directly.
442 Making the program flexible on the number of entries it prints,
443 is easily possible:
444 .DS I 2n
445 .CW
446 .ps -1
447 #!/bin/sh
448 num=5
449 [ $# -eq 1 ] && num="$1"
450 du -sh * | sort -nr | sed "${num}q"
451 .DE
452 This script acts like the one before, when called without an argument.
453 But one can also specify a numerical argument to define the number of lines to print.
455 .NH 2
456 A powerful shell
457 .LP
458 It was already said, that the Unix shell provides the possibility to
459 combine small programs into large ones easily.
460 A powerful shell is a great feature in other ways, too.
461 .PP
462 For instance by including a scripting language.
463 The control statements are build into the shell.
464 The functions, however, are the normal programs, everyone can use on the system.
465 Thus, the programs are known, so learning to program in the shell is easy.
466 Using normal programs as functions in the shell programming language
467 is only possible because they are small and combinable tools in a toolchest style.
468 .PP
469 The Unix shell encourages to write small scripts out of other programs,
470 because it is so easy to do.
471 This is a great step towards automation.
472 It is wonderful if the effort to automate a task equals the effort
473 it takes to do it the second time by hand.
474 If it is so, then the user will be happy to automate everything he does more than once.
475 .PP
476 Small programs that do one job well, standardized interfaces between them,
477 a mechanism to combine parts to larger parts, and an easy way to automate tasks,
478 this will inevitably produce software leverage.
479 Getting multiple times the benefit of an investment is a great offer.
480 .PP
481 The shell also encourages rapid prototyping.
482 Many well known programs started as quickly hacked shell scripts,
483 and turned into ``real'' programs, written in C, later.
484 Building a prototype first is a way to avoid the biggest problems
485 in application development.
486 Fred Brooks writes in ``No Silver Bullet'':
487 .[
488 %A Frederick P. Brooks, Jr.
489 %T No Silver Bullet: Essence and Accidents of Software Engineering
490 %B Information Processing 1986, the Proceedings of the IFIP Tenth World Computing Conference
491 %E H.-J. Kugler
492 %D 1986
493 %P 1069\(en1076
494 %I Elsevier Science B.V.
495 %C Amsterdam, The Netherlands
496 .]
497 .QP
498 The hardest single part of building a software system is deciding precisely what to build.
499 No other part of the conceptual work is so difficult as establishing the detailed
500 technical requirements, [...].
501 No other part of the work so cripples the resulting system if done wrong.
502 No other part is more difficult to rectify later.
503 .PP
504 Writing a prototype is a great method to become familiar with the requirements
505 and to actually run into real problems.
506 Today, prototyping is often seen as a first step in building a software.
507 This is, of course, good.
508 However, the Unix Philosophy has an \fIadditional\fP perspective on prototyping:
509 After having built the prototype, one might notice, that the prototype is already
510 \fIgood enough\fP.
511 Hence, no reimplementation, in a more sophisticated programming language, might be of need,
512 for the moment.
513 Maybe later, it might be necessary to rewrite the software, but not now.
514 .PP
515 By delaying further work, one keeps the flexibility to react easily on
516 changing requirements.
517 Software parts that are not written will not miss the requirements.
519 .NH 2
520 Worse is better
521 .LP
522 The Unix Philosophy aims for the 80% solution;
523 others call it the ``Worse is better'' approach.
524 .PP
525 First, practical experience shows, that it is almost never possible to define the
526 requirements completely and correctly the first time.
527 Hence one should not try to; it will fail anyway.
528 Second, practical experience shows, that requirements change during time.
529 Hence it is best to delay requirement-based design decisions as long as possible.
530 Also, the software should be small and flexible as long as possible
531 to react on changing requirements.
532 Shell scripts, for example, are more easily adjusted as C programs.
533 Third, practical experience shows, that maintenance is hard work.
534 Hence, one should keep the amount of software as small as possible;
535 it should just fulfill the \fIcurrent\fP requirements.
536 Software parts that will be written later, do not need maintenance now.
537 .PP
538 Starting with a prototype in a scripting language has several advantages:
539 .IP \(bu
540 As the initial effort is low, one will likely start right away.
541 .IP \(bu
542 As working parts are available soon, the real requirements can get identified soon.
543 .IP \(bu
544 When a software is usable, it gets used, and thus tested.
545 Hence problems will be found at early stages of the development.
546 .IP \(bu
547 The prototype might be enough for the moment,
548 thus further work on the software can be delayed to a time
549 when one knows better about the requirements and problems,
550 than now.
551 .IP \(bu
552 Implementing now only the parts that are actually needed now,
553 requires fewer maintenance work.
554 .IP \(bu
555 If the global situation changes so that the software is not needed anymore,
556 then less effort was spent into the project, than it would have be
557 when a different approach had been used.
559 .NH 2
560 Upgrowth and survival of software
561 .LP
562 So far it was talked about \fIwriting\fP or \fIbuilding\fP software.
563 Although these are just verbs, they do imply a specific view on the work process
564 they describe.
565 The better verb, however, is to \fIgrow\fP.
566 .PP
567 Creating software in the sense of the Unix Philosophy is an incremental process.
568 It starts with a first prototype, which evolves as requirements change.
569 A quickly hacked shell script might become a large, sophisticated,
570 compiled program this way.
571 Its lifetime begins with the initial prototype and ends when the software is not used anymore.
572 While being alive it will get extended, rearranged, rebuilt (from scratch).
573 Growing software matches the view that ``software is never finished. It is only released.''
574 .[
575 %O FIXME
576 %A Mike Gancarz
577 %T The UNIX Philosophy
578 %P 26
579 .]
580 .PP
581 Software can be seen as being controlled by evolutionary processes.
582 Successful software is software that is used by many for a long time.
583 This implies that the software is needed, useful, and better than alternatives.
584 Darwin talks about: ``The survival of the fittest.''
585 .[
586 %O FIXME
587 %A Charles Darwin
588 .]
589 Transferred to software: The most successful software, is the fittest,
590 is the one that survives.
591 (This may be at the level of one creature, or at the level of one species.)
592 The fitness of software is affected mainly by four properties:
593 portability of code, portability of data, range of usability, and reusability of parts.
594 .\" .IP \(bu
595 .\" portability of code
596 .\" .IP \(bu
597 .\" portability of data
598 .\" .IP \(bu
599 .\" range of usability
600 .\" .IP \(bu
601 .\" reuseability of parts
602 .PP
603 (1)
604 .I "Portability of code
605 means, using high-level programming languages,
606 sticking to the standard,
607 and avoiding optimizations that introduce dependencies on specific hardware.
608 Hardware has a much lower lifetime than software.
609 By chaining software to a specific hardware,
610 the software's lifetime gets shortened to that of this hardware.
611 In contrast, software should be easy to port \(en
612 adaptation is the key to success.
613 .\" cf. practice of prog: ch08
614 .PP
615 (2)
616 .I "Portability of data
617 is best achieved by avoiding binary representations
618 to store data, because binary representations differ from machine to machine.
619 Textual representation is favored.
620 Historically, ASCII was the charset of choice.
621 In the future, UTF-8 might be the better choice, however.
622 Important is that it is a plain text representation in a
623 very common charset encoding.
624 Apart from being able to transfer data between machines,
625 readable data has the great advantage, that humans are able
626 to directly edit it with text editors and other tools from the Unix toolchest.
627 .\" gancarz tenet 5
628 .PP
629 (3)
630 A large
631 .I "range of usability
632 ensures good adaptation, and thus good survival.
633 It is a special distinction if a software becomes used in fields of action,
634 the original authors did never imagine.
635 Software that solves problems in a general way will likely be used
636 for all kinds of similar problems.
637 Being too specific limits the range of uses.
638 Requirements change through time, thus use cases change or even vanish.
639 A good example in this point is Allman's sendmail.
640 Allman identifies flexibility to be one major reason for sendmail's success:
641 .[
642 %O FIXME
643 %A Allman
644 %T sendmail
645 .]
646 .QP
647 Second, I limited myself to the routing function [...].
648 This was a departure from the dominant thought of the time, [...].
649 .QP
650 Third, the sendmail configuration file was flexible enough to adopt
651 to a rapidly changing world [...].
652 .LP
653 Successful software adopts itself to the changing world.
654 .PP
655 (4)
656 .I "Reuse of parts
657 is even one step further.
658 A software may completely lose its field of action,
659 but parts of which the software is build may be general and independent enough
660 to survive this death.
661 If software is build by combining small independent programs,
662 then there are parts readily available for reuse.
663 Who cares if the large program is a failure,
664 but parts of it become successful instead?
666 .NH 2
667 Summary
668 .LP
669 This chapter explained the central ideas of the Unix Philosophy.
670 For each of the ideas, it was exposed what advantages they introduce.
671 The Unix Philosophy are guidelines that help to write valuable software.
672 From the view point of a software developer or software designer,
673 the Unix Philosophy provides answers to many software design problem.
674 .PP
675 The various ideas of the Unix Philosophy are very interweaved
676 and can hardly be applied independently.
677 However, the probably most important messages are:
678 .I "``Do one thing well!''" ,
679 .I "``Keep it simple!''" ,
680 and
681 .I "``Use software leverage!''
685 .NH 1
686 Case study: \s-1MH\s0
687 .LP
688 The previous chapter introduced and explained the Unix Philosophy
689 from a general point of view.
690 The driving force were the guidelines; references to
691 existing software were given only sparsely.
692 In this and the next chapter, concrete software will be
693 the driving force in the discussion.
694 .PP
695 This first case study is about the mail user agents (\s-1MUA\s0)
696 \s-1MH\s0 (``mail handler'') and its descendent \fInmh\fP
697 (``new mail handler'').
698 \s-1MUA\s0s provide functions to read, compose, and organize mail,
699 but (ideally) not to transfer.
700 In this document, the name \s-1MH\s0 will be used for both of them.
701 A distinction will only be made if differences between
702 them are described.
705 .NH 2
706 Historical background
707 .LP
708 Electronic mail was available in Unix very early.
709 The first \s-1MUA\s0 on Unix was \f(CWmail\fP,
710 which was already present in the First Edition.
711 .[
712 %A Peter H. Salus
713 %T A Quarter Century of UNIX
714 %D 1994
715 %I Addison-Wesley
716 %P 41 f.
717 .]
718 It was a small program that either prints the user's mailbox file
719 or appends text to someone elses mailbox file,
720 depending on the command line arguments.
721 .[
722 %O
723 .]
724 It was a program that did one job well.
725 This job was emailing, which was very simple then.
726 .PP
727 Later, emailing became more powerful, and thus more complex.
728 The simple \f(CWmail\fP, which knew nothing of subjects,
729 independent handling of single messages,
730 and long-time storage of them, was not powerful enough anymore.
731 At Berkeley, Kurt Shoens wrote \fIMail\fP (with capital `M')
732 in 1978 to provide additional functions for emailing.
733 Mail was still one program, but now it was large and did
734 several jobs.
735 Its user interface is modeled after the one of \fIed\fP.
736 It is designed for humans, but is still scriptable.
737 \fImailx\fP is the adaptation of Berkeley Mail into System V.
738 .[
739 %A Gunnar Ritter
740 %O
741 .]
742 Elm, pine, mutt, and a whole bunch of graphical \s-1MUA\s0s
743 followed Mail's direction.
744 They are large, monolithic programs which include all emailing functions.
745 .PP
746 A different way was taken by the people of \s-1RAND\s0 Corporation.
747 In the beginning, they also had used a monolithic mail system,
748 called \s-1MS\s0 (for ``mail system'').
749 But in 1977, Stockton Gaines and Norman Shapiro
750 came up with a proposal of a new email system concept \(en
751 one that honors the Unix Philosophy.
752 The concept was implemented by Bruce Borden in 1978 and 1979.
753 This was the birth of \s-1MH\s0 \(en the ``mail handler''.
754 .PP
755 Since then, \s-1RAND\s0, the University of California at Irvine and
756 at Berkeley, and several others have contributed to the software.
757 However, it's core concepts remained the same.
758 In the late 90s, when development of \s-1MH\s0 slowed down,
759 Richard Coleman started with \fInmh\fP, the new mail handler.
760 His goal was to improve \s-1MH\s0, especially in regard of
761 the requirements of modern emailing.
762 Today, nmh is developed by various people on the Internet.
763 .[
764 %T RAND and the Information Evolution: A History in Essays and Vignettes
765 %A Willis H. Ware
766 %D 2008
767 %I The RAND Corporation
768 %P 128\(en137
769 %O .CW \s-1
770 .]
771 .[
772 %T MH & xmh: Email for Users & Programmers
773 %A Jerry Peek
774 %D 1991, 1992, 1995
775 %I O'Reilly & Associates, Inc.
776 %P Appendix B
777 %O Also available online: \f(CW\s-2\fP
778 .]
780 .NH 2
781 Contrasts to monolithic mail systems
782 .LP
783 All \s-1MUA\s0s are monolithic, except \s-1MH\s0.
784 Although there might actually exist further, very little known,
785 toolchest \s-1MUA\s0s, this statement reflects the situation pretty well.
786 .PP
787 Monolithic \s-1MUA\s0s gather all their functions in one program.
788 In contrast, \s-1MH\s0 is a toolchest of many small tools \(en one for each job.
789 Following is a list of important programs of \s-1MH\s0's toolchest
790 and their function.
791 It gives a feeling of how the toolchest looks like.
792 .IP \(bu
793 .CW inc :
794 incorporate new mail (this is how mail enters the system)
795 .IP \(bu
796 .CW scan :
797 list messages in folder
798 .IP \(bu
799 .CW show :
800 show message
801 .IP \(bu
802 .CW next\fR/\fPprev :
803 show next/previous message
804 .IP \(bu
805 .CW folder :
806 change current folder
807 .IP \(bu
808 .CW refile :
809 refile message into folder
810 .IP \(bu
811 .CW rmm :
812 remove message
813 .IP \(bu
814 .CW comp :
815 compose a new message
816 .IP \(bu
817 .CW repl :
818 reply to a message
819 .IP \(bu
820 .CW forw :
821 forward a message
822 .IP \(bu
823 .CW send :
824 send a prepared message (this is how mail leaves the system)
825 .LP
826 \s-1MH\s0 has no special user interface like monolithic \s-1MUA\s0s have.
827 The user does not leave the shell to run \s-1MH\s0,
828 but he uses the various \s-1MH\s0 programs within the shell.
829 Using a monolithic program with a captive user interface
830 means ``entering'' the program, using it, and ``exiting'' the program.
831 Using toolchests like \s-1MH\s0 means running programs,
832 alone or in combination with others, even from other toolchests,
833 without leaving the shell.
835 .NH 2
836 Data storage
837 .LP
838 \s-1MH\s0's mail storage is a directory tree under the user's
839 \s-1MH\s0 directory (usually \f(CW$HOME/Mail\fP),
840 where mail folders are directories and mail messages are text files
841 within them.
842 Each mail folder contains a file \f(CW.mh_sequences\fP which lists
843 the public message sequences of that folder, for instance new messages.
844 Mail messages are text files located in a mail folder.
845 The files contain the messages as they were received.
846 They are numbered in ascending order in each folder.
847 .PP
848 This mailbox format is called ``\s-1MH\s0'' after the \s-1MUA\s0.
849 Alternatives are \fImbox\fP and \fImaildir\fP.
850 In the mbox format all messages are stored within one file.
851 This was a good solution in the early days, when messages
852 were only a few lines of text and were deleted soon.
853 Today, when single messages often include several megabytes
854 of attachments, it is a bad solution.
855 Another disadvantage of the mbox format is that it is
856 more difficult to write tools that work on mail messages,
857 because it is always necessary to first find and extract
858 the relevant message in the mbox file.
859 With the \s-1MH\s0 mailbox format,
860 each message is a self-standing item, by definition.
861 Also, the problem of concurrent access to one mailbox is
862 reduced to the problem of concurrent access to one message.
863 Maildir is generally similar to \s-1MH\s0's format,
864 but modified towards guaranteed reliability.
865 This involves some complexity, unfortunately.
866 .PP
867 Working with \s-1MH\s0's toolchest on mailboxes is much like
868 working with Unix' toolchest on directory trees:
869 \f(CWscan\fP is like \f(CWls\fP,
870 \f(CWshow\fP is like \f(CWcat\fP,
871 \f(CWfolder\fP is like \f(CWcd\fP and \f(CWpwd\fP,
872 \f(CWrefile\fP is like \f(CWmv\fP,
873 and \f(CWrmm\fP is like \f(CWrm\fP.
874 .PP
875 The context of tools in Unix consists mainly the current working directory,
876 the user identification, and the environment variables.
877 \s-1MH\s0 extends this context by two more items:
878 .IP \(bu
879 The current mail folder, which is similar to the current working directory.
880 For mail folders, \f(CWfolder\fP provides the corresponding functionality
881 of \f(CWcd\fP and \f(CWpwd\fP for directories.
882 .IP \(bu
883 Sequences, which are named sets of messages in a mail folder.
884 The current message, relative to a mail folder, is a special sequence.
885 It enables commands like \f(CWnext\fP and \f(CWprev\fP.
886 .LP
887 In contrast to Unix' context, which is chained to the shell session,
888 \s-1MH\s0's context is independent.
889 Usually there is one context for each user, but a user can have many
890 contexts.
891 Public sequences are an exception, as they belong to the mail folder.
892 .[
893 %O mh-profile(5) and mh-sequence(5)
894 .]
896 .NH 2
897 Discussion of the design
898 .LP
899 The following paragraphs discuss \s-1MH\s0 in regard to the tenets
900 of the Unix Philosophy which Gancarz identified.
902 .PP
903 .B "Small is beautiful
904 and
905 .B "do one thing well
906 are two design goals that are directly visible in \s-1MH\s0.
907 Gancarz actually presents \s-1MH\s0 as example under the headline
908 ``Making UNIX Do One Thing Well'':
909 .QP
910 [\s-1MH\s0] consists of a series of programs which
911 when combined give the user an enormous ability
912 to manipulate electronic mail messages.
913 A complex application, it shows that not only is it
914 possible to build large applications from smaller
915 components, but also that such designs are actually preferable.
916 .[
917 %A Mike Gancarz
918 %T unix-phil
919 %P 125
920 .]
921 .LP
922 The various small programs of \s-1MH\s0 were relatively easy
923 to write, because each of them is small, limited to one function,
924 and has clear boundaries.
925 For the same reasons, they are also good to maintain.
926 Further more, the system can easily get extended.
927 One only needs to put a new program into the toolchest.
928 This was done, for instance, when \s-1MIME\s0 support was added
929 (e.g. \f(CWmhbuild\fP).
930 Also, different programs can exist to do the basically same job
931 in different ways (e.g. in nmh: \f(CWshow\fP and \f(CWmhshow\fP).
932 If someone needs a mail system with some additionally
933 functions that are available nowhere yet, he best takes a
934 toolchest system like \s-1MH\s0 where he can add the
935 functionality with little work.
937 .PP
938 .B "Store data in flat text files
939 is followed by \s-1MH\s0.
940 This is not surprising, because email messages are already plain text.
941 \s-1MH\s0 stores the messages as it receives them,
942 thus any other tool that works on RFC 2822 mail messages can operate
943 on the messages in an \s-1MH\s0 mailbox.
944 All other files \s-1MH\s0 uses are plain text too.
945 It is therefore possible and encouraged to use the text processing
946 tools of Unix' toolchest to extend \s-1MH\s0's toolchest.
948 .PP
949 .B "Avoid captive user interfaces" .
950 \s-1MH\s0 is perfectly suited for non-interactive use.
951 It offers all functions directly and without captive user interfaces.
952 If, nonetheless, users want a graphical user interface,
953 they can have it with \fIxmh\fP or \fIexmh\fP, too.
954 These are graphical frontends for the \s-1MH\s0 toolchest.
955 This means, all email-related work is still done by \s-1MH\s0 tools,
956 but the frontend issues the appropriate calls when the user
957 clicks on buttons.
958 Providing easy-to-use user interfaces in form of frontends is a good
959 approach, because it does not limit the power of the backend itself.
960 The frontend will anyway only be able to make a subset of the
961 backend's power and flexibility available to the user.
962 But if it is a separate program,
963 then the missing parts can still be accessed at the backend directly.
964 If it is integrated, then this will hardly be possible.
965 Further more, it is possible to have different frontends to the same
966 backend.
968 .PP
969 .B "Choose portability over efficiency
970 and
971 .B "use shell scripts to increase leverage and portability" .
972 These two tenets are indirectly, but nicely, demonstrated by
973 Bolsky and Korn in their book about the Korn Shell.
974 .[
975 %T The KornShell: command and programming language
976 %A Morris I. Bolsky
977 %A David G. Korn
978 %I Prentice Hall
979 %D 1989
980 %P 254\(en290
981 %O \s-1ISBN\s0: 0-13-516972-0
982 .]
983 They demonstrated, in chapter 18 of the book, a basic implementation
984 of a subset of \s-1MH\s0 in ksh scripts.
985 Of course, this was just a demonstration, but a brilliant one.
986 It shows how quickly one can implement such a prototype with shell scripts,
987 and how readable they are.
988 The implementation in the scripting language may not be very fast,
989 but it can be fast enough though, and this is all that matters.
990 By having the code in an interpreted language, like the shell,
991 portability becomes a minor issue, if we assume the interpreter
992 to be widespread.
993 This demonstration also shows how easy it is to create single programs
994 of a toolchest software.
995 There are eight tools (two of them have multiple names) and 16 functions
996 with supporting code.
997 Each tool comprises between 12 and 38 lines of ksh,
998 in total about 200 lines.
999 The functions comprise between 3 and 78 lines of ksh,
1000 in total about 450 lines.
1001 Such small software is easy to write, easy to understand,
1002 and thus easy to maintain.
1003 A toolchest improves the possibility to only write some parts
1004 and though create a working result.
1005 Expanding the toolchest without global changes will likely be
1006 possible, too.
1008 .PP
1009 .B "Use software leverage to your advantage
1010 and the lesser tenet
1011 .B "allow the user to tailor the environment
1012 are ideally followed in the design of \s-1MH\s0.
1013 Tailoring the environment is heavily encouraged by the ability to
1014 directly define default options to programs.
1015 It is even possible to define different default options
1016 depending on the name under which the program was called.
1017 Software leverage is heavily encouraged by the ease it is to
1018 create shell scripts that run a specific command line,
1019 built of several \s-1MH\s0 programs.
1020 There is few software that so much wants users to tailor their
1021 environment and to leverage the use of the software, like \s-1MH\s0.
1022 Just to make one example:
1023 One might prefer a different listing format for the \f(CWscan\fP
1024 program.
1025 It is possible to take one of the distributed format files
1026 or to write one yourself.
1027 To use the format as default for \f(CWscan\fP, a single line,
1028 reading
1029 .DS
1030 .CW
1031 scan: -form FORMATFILE
1032 .DE
1033 must be added to \f(CW.mh_profile\fP.
1034 If one wants this different format as an additional command,
1035 instead of changing the default, he needs to create a link to
1036 \f(CWscan\fP, for instance titled \f(CWscan2\fP.
1037 The line in \f(CW.mh_profile\fP would then start with \f(CWscan2\fP,
1038 as the option should only be in effect when scan is called as
1039 \f(CWscan2\fP.
1041 .PP
1042 .B "Make every program a filter
1043 is hard to find in \s-1MH\s0.
1044 The reason therefore is that most of \s-1MH\s0's tools provide
1045 basic file system operations for the mailboxes.
1046 The reason is the same because of which
1047 \f(CWls\fP, \f(CWcp\fP, \f(CWmv\fP, and \f(CWrm\fP
1048 aren't filters neither.
1049 However, they build a basis on which filters can operate.
1050 \s-1MH\s0 does not provide many filters itself, but it is a basis
1051 to write filters for.
1052 An example would be a mail message text highlighter,
1053 that means a program that makes use of a color terminal to display
1054 header lines, quotations, and signatures in distinct colors.
1055 The author's version of this program, for instance,
1056 is a 25 line awk script.
1058 .PP
1059 .B "Build a prototype as soon as possible
1060 was again well followed by \s-1MH\s0.
1061 This tenet, of course, focuses on early development, which is
1062 long time ago for \s-1MH\s0.
1063 But without following this guideline at the very beginning,
1064 Bruce Borden may have not convinced the management of \s-1RAND\s0
1065 to ever create \s-1MH\s0.
1066 In Bruce' own words:
1067 .QP
1068 [...] but they [Stockton Gaines and Norm Shapiro] were not able
1069 to convince anyone that such a system would be fast enough to be usable.
1070 I proposed a very short project to prove the basic concepts,
1071 and my management agreed.
1072 Looking back, I realize that I had been very lucky with my first design.
1073 Without nearly enough design work,
1074 I built a working environment and some header files
1075 with key structures and wrote the first few \s-1MH\s0 commands:
1076 inc, show/next/prev, and comp.
1077 [...]
1078 With these three, I was able to convince people that the structure was viable.
1079 This took about three weeks.
1080 .[
1081 %O FIXME
1082 .]
1084 .NH 2
1085 Problems
1086 .LP
1087 \s-1MH\s0, for sure is not without problems.
1088 There are two main problems: one is technical, the other is about human behavior.
1089 .PP
1090 \s-1MH\s0 is old and email today is very different to email in the time
1091 when \s-1MH\s0 was designed.
1092 \s-1MH\s0 adopted to the changes pretty well, but it is limited.
1093 For example in development resources.
1094 \s-1MIME\s0 support and support for different character encodings
1095 is available, but only on a moderate level.
1096 More active developers could quickly improve there.
1097 It is also limited by design, which is the larger problem.
1098 \s-1IMAP\s0, for example, conflicts with \s-1MH\s0's design to a large extend.
1099 These design conflicts are not easily solvable.
1100 Possibly, they require a redesign.
1101 Maybe \s-1IMAP\s0 is too different to the classic mail model which \s-1MH\s0 covers,
1102 hence \s-1MH\s0 may never work well with \s-1IMAP\s0.
1103 .PP
1104 The other kind of problem is human habits.
1105 When in this world almost all \s-1MUA\s0s are monolithic,
1106 it is very difficult to convince people to use a toolbox style \s-1MUA\s0
1107 like \s-1MH\s0.
1108 The habits are so strong, that even people who understood the concept
1109 and advantages of \s-1MH\s0 do not like to switch,
1110 simply because \s-1MH\s0 is different.
1111 Unfortunately, the frontends to \s-1MH\s0, which could provide familiar look'n'feel,
1112 are quite outdated and thus not very appealing compared to the modern interfaces
1113 which monolithic \s-1MUA\s0s offer.
1115 .NH 2
1116 Summary \s-1MH\s0
1117 .LP
1118 \s-1MH\s0 is an \s-1MUA\s0 that follows the Unix Philosophy in its design
1119 and implementation.
1120 It consists of a toolchest of small tools, each of them does one job well.
1121 The tools are orthogonal to each other, to a large extend.
1122 However, for historical reasons, there also exist distinct tools
1123 that cover the same task.
1124 .PP
1125 The toolchest approach offers great flexibility to the user.
1126 He can use the complete power of the Unix shell with \s-1MH\s0.
1127 This makes \s-1MH\s0 a very powerful mail system.
1128 Extending and customizing \s-1MH\s0 is easy and encouraged, too.
1129 .PP
1130 Apart from the user's perspective, \s-1MH\s0 is development-friendly.
1131 Its overall design follows clear rules.
1132 The single tools do only one job, thus they are easy to understand,
1133 easy to write, and good to maintain.
1134 They are all independent and do not interfere with the others.
1135 Automated testing of their function is a straight forward task.
1136 .PP
1137 It is sad, that \s-1MH\s0's differentness is its largest problem,
1138 as its differentness is also its largest advantage.
1139 Unfortunately, for most people their habits are stronger
1140 than the attraction of the clear design and the power, \s-1MH\s0 offers.
1144 .NH 1
1145 Case study: uzbl
1146 .LP
1147 The last chapter took a look on the \s-1MUA\s0 \s-1MH\s0,
1148 this chapter is about uzbl, a web browser that adheres to the Unix Philosophy.
1149 ``uzbl'' is the \fIlolcat\fP's word for the English adjective ``usable''.
1150 It is pronounced the identical.
1152 .NH 2
1153 Historical background
1154 .LP
1155 Uzbl was started by Dieter Plaetinck in April 2009.
1156 The idea was born in a thread in the Arch Linux forum.
1157 .[
1158 %O
1159 .]
1160 After some discussion about failures of well known web browsers,
1161 Plaetinck (alias Dieter@be) came up with a very sketchy proposal
1162 of how a better web browser could look like.
1163 To the question of another member, if Plaetinck would write that program,
1164 because it would sound fantastic, Plaetinck replied:
1165 ``Maybe, if I find the time ;-)''.
1166 .PP
1167 Fortunately, he found the time.
1168 One day later, the first prototype was out.
1169 One week later, uzbl had an own website.
1170 One month after the first code showed up,
1171 a mailing list was installed to coordinate and discuss further development.
1172 A wiki was set up to store documentation and scripts that showed up on the
1173 mailing list and elsewhere.
1174 .PP
1175 In the, now, one year of uzbl's existence, it was heavily developed in various branches.
1176 Plaetinck's task became more and more to only merge the best code from the
1177 different branches into his main branch, and to apply patches.
1178 About once a month, Plaetinck released a new version.
1179 In September 2009, he presented several forks of uzbl.
1180 Uzbl, actually, opened the field for a whole family of web browsers with similar shape.
1181 .PP
1182 In July 2009, \fILinux Weekly News\fP published an interview with Plaetinck about uzbl.
1183 In September 2009, the uzbl web browser was on \fISlashdot\fP.
1185 .NH 2
1186 Contrasts to other web browsers
1187 .LP
1188 Like most \s-1MUA\s0s are monolithic, but \s-1MH\s0 is a toolchest,
1189 most web browsers are monolithic, but uzbl is a frontend to a toolchest.
1190 .PP
1191 Today, uzbl is divided into uzbl-core and uzbl-browser.
1192 Uzbl-core is, how its name already indicates, the core of uzbl.
1193 It handles commands and events to interface other programs,
1194 and also displays webpages by using webkit as render engine.
1195 Uzbl-browser combines uzbl-core with a bunch of handler scripts, a status bar,
1196 an event manager, yanking, pasting, page searching, zooming, and more stuff,
1197 to form a ``complete'' web browser.
1198 In the following text, the term ``uzbl'' usually stands for uzbl-browser,
1199 so uzbl-core is included.
1200 .PP
1201 Unlike most other web browsers, uzbl is mainly the mediator between the
1202 various tools that cover single jobs of web browsing.
1203 Therefore, uzbl listens for commands on a named pipe (fifo), a Unix socket,
1204 and on stdin, and it writes events to a Unix socket and to stdout.
1205 The graphical rendering of the webpage is done by webkit, a web content engine.
1206 Uzbl-core is build around this library.
1207 Loading a webpage in a running uzbl instance requires only:
1208 .DS
1209 .CW
1210 echo 'uri' >/path/to/uzbl-fifo
1211 .DE
1212 .PP
1213 Downloads, browsing history, bookmarks, and thelike are not provided
1214 by uzbl-core itself, as they are in other web browsers.
1215 Uzbl-browser also only provides, so called, handler scripts that wrap
1216 external applications which provide the actual functionality.
1217 For instance, \fIwget\fP is used to download files and uzbl-browser
1218 includes a script that calls wget with appropriate options in
1219 a prepared environment.
1220 .PP
1221 Modern web browsers are proud to have addons, plugins, and modules, instead.
1222 This is their effort to achieve similar goals.
1223 But instead of using existing, external programs, modern web browsers
1224 include these functions, although they might be loaded at runtime.
1226 .NH 2
1227 Discussion of the design
1228 .LP
1229 This section discusses uzbl in regard of the Unix Philosophy,
1230 as identified by Gancarz.
1232 .PP
1233 .B "Make each program do one thing well" .
1234 Uzbl tries to be a web browser and nothing else.
1235 The common definition of a web browser is, of course, highly influenced by
1236 existing implementations of web browsers, although they are degenerated.
1237 Web browsers should be programs to browse the web, and nothing more.
1238 This is the one thing they should do, as demanded by the Unix Philosophy.
1239 .PP
1240 Web browsers should, for instance, not manage downloads.
1241 This is the job download managers exist for.
1242 Download managers do primary care about being good in downloading files.
1243 Modern web browsers provide download management only as a secondary feature.
1244 How could they perform this job better, than programs that exist only for
1245 this very job?
1246 And how could anyone want less than the best download manager available?
1247 .PP
1248 A web browser's job is to let the user browse the web.
1249 This means, navigating through websites by following links.
1250 Rendering the \s-1HTML\s0 sources is a different job, too.
1251 It is covered by the webkit render engine, in uzbl's case.
1252 Audio and video content and files like PostScript, \s-1PDF\s0, and the like,
1253 are also not the job of a web browser.
1254 They should be handled by external applications \(en
1255 ones which's job is to handle such data.
1256 Uzbl strives to do it this way.
1257 .PP
1258 Remember Doug McIlroy:
1259 .I
1260 ``Write programs that do one thing and do it well.
1261 Write programs to work together.''
1262 .R
1263 .PP
1264 The lesser tenet
1265 .B "allow the user to tailor the environment
1266 matches good here.
1267 There was the question, how anyone could want anything less than the
1268 best program for the job.
1269 But as personal preferences matter much,
1270 it is probably more important to ask:
1271 How could anyone want something else than his preferred program for the job?
1272 .PP
1273 Usually users want one program for one job.
1274 Hence, whenever the task is, for instance, downloading,
1275 exactly one download manager should be used.
1276 More advanced users might want to have this download manager in this
1277 situation and that one in that situation.
1278 They should be able to configure it this way.
1279 With uzbl, one can use any download manager the user wants.
1280 To switch to a different one, only one line in a small handler script
1281 needs to be changed.
1282 Alternatively it would be possible to query an entry in a global file
1283 or an environment variable, which specifies the download manager to use,
1284 in the handler script.
1285 .PP
1286 As uzbl does neither have its own download manager nor depends on a
1287 specific one, thus uzbl's browsing abilities will not be lowered by having
1288 a bad download manager.
1289 Uzbl's download capabilities will just as good as the ones of the best
1290 download manager available on the system.
1291 Of course, this applies to all of the other supplementary tools, too.
1293 .PP
1294 .B "Use software leverage to your advantage" .
1295 Shell scripts are a good choice to extend uzbl.
1296 Uzbl is designed to be extended by external tools.
1297 These external tools are usually wrapped by small handler shell scripts.
1298 Shell scripts are the glue in this approach.
1299 They make the various parts fit together.
1300 .PP
1301 As an example, the history mechanism of uzbl shall be presented.
1302 Uzbl is configured to spawn a script to append an entry to the history
1303 whenever the event of a fully loaded page occurs.
1304 The script to append the entry to the history not much more than:
1305 .DS
1306 .CW
1307 #!/bin/sh
1308 file=/path/to/uzbl-history
1309 echo `date +'%Y-%m-%d %H:%M:%S'`" $6 $7" >> $file
1310 .DE
1311 \f(CW$6\fP and \f(CW$7\fP expand to the \s-1URL\s0 and the page title.
1312 For loading an entry, a key is bound to spawn a load from history script.
1313 The script reverses the history to have newer entries first,
1314 then displays \fIdmenu\fP to select an item,
1315 and afterwards writes the selected \s-1URL\s0 into uzbl's command input pipe.
1316 With error checking and corner cases removed, the script looks like this:
1317 .DS
1318 .CW
1319 #!/bin/sh
1320 file=/path/to/uzbl-history
1321 goto=`tac $file | dmenu | cut -d' ' -f 3`
1322 echo "uri $goto" > $4
1323 .DE
1324 \f(CW$4\fP expands to the path of the command input pipe of the current
1325 uzbl instance.
1327 .PP
1328 .B "Avoid captive user interfaces" .
1329 One could say, that uzbl, to a large extend, actually \fIis\fP
1330 a captive user interface.
1331 But the difference to most other web browsers is, that uzbl is only
1332 the captive user interface frontend and the core of the backend.
1333 Many parts of the backend are independent of uzbl.
1334 Some are distributed with uzbl, for some external programs, handler scripts
1335 are distributed, arbitrary additional functionality can be added if desired.
1336 .PP
1337 The frontend is captive \(en that is true.
1338 This is okay for the task of browsing the web, as this task is only relevant
1339 for humans.
1340 Automated programs would \fIcrawl\fP the web.
1341 That means, they read the source directly.
1342 The source includes all the semantics.
1343 The graphical representation is just for humans to transfer the semantics
1344 more intuitively.
1346 .PP
1347 .B "Make every program a filter" .
1348 Graphical web browsers are almost dead ends in the chain of information flow.
1349 Thus it is difficult to see what graphical web browsers should filter.
1350 Graphical web browsers exist almost only for interactive use by humans.
1351 The only case when one might want to automate the rendering function is
1352 to generate images of rendered webpages.
1354 .PP
1355 .B "Small is beautiful"
1356 is not easy to apply to a web browser, primary because modern web technology
1357 is very complex; hence the rendering task is very complex.
1358 Modern web browsers will always consist of many thousand lines of code,
1359 unfortunately.
1360 Using the toolchest approach and wrappers can split the browser into
1361 several small parts, tough.
1362 .PP
1363 Uzbl-core consists of about 3\,500 lines of C code.
1364 The distribution includes another 3\,500 lines of Shell and Python code,
1365 which are the handler scripts and plugins like a modal interface.
1366 Further more, uzbl uses functionality of external tools like
1367 \fIwget\fP and \fInetcat\fP.
1368 Up to this point, uzbl looks pretty neat and small.
1369 The ugly part of uzbl is the web content renderer, webkit.
1370 Webkit consists of roughly 400\,000 (!) lines of code.
1371 Unfortunately, small web render engines are not possible anymore
1372 because of the modern web.
1373 The problems section will explain this in more detail.
1375 .PP
1376 .B "Build a prototype as soon as possible" .
1377 Plaetinck made his code public, right from the beginning.
1378 Discussion and development was, and still is, open to everyone interested.
1379 Development versions of uzbl can be obtained very simply from the code
1380 repository.
1381 Within the first year of uzbl's existence, a new version was released
1382 more often than once a month.
1383 Different forks and branches arose.
1384 They introduced new features, which were tested for suitability.
1385 The experiences of using prototypes influenced further development.
1386 Actually, all development was community driven.
1387 Plaetinck says, three months after uzbl's birth:
1388 ``Right now I hardly code anything myself for Uzbl.
1389 I just merge in other people's code, ponder a lot, and lead the discussions.''
1390 .[
1391 %A FIXME
1392 %O
1393 .]
1396 .NH 2
1397 Problems
1398 .LP
1399 Similar to \s-1MH\s0, uzbl, too suffers from being different.
1400 It is sad, but people use what they know.
1401 Fortunately, uzbl's user interface can look and feel very much the
1402 same as the one of the well known web browsers,
1403 hiding the internal differences.
1404 But uzbl has to provide this similar look and feel to be accepted
1405 as a ``normal'' browser by ``normal'' users.
1406 .PP
1407 The more important problem is the modern web.
1408 The modern web is simply broken.
1409 It has state in a state-less protocol,
1410 it misuses technologies,
1411 and it is helplessly overloaded.
1412 The result are web content render engines that must consist
1413 of hundreds of thousands lines of code.
1414 They also must combine and integrate many different technologies,
1415 only to make our modern web usable.
1416 Website to image converter are hardly possible to run without
1417 human interaction because of state in sessions, impossible
1418 deep-linking, and unautomatable technologies.
1419 .PP
1420 The web was misused to provide all kinds of imaginable wishes.
1421 Now web browsers, and eventually the users, suffer from it.
1424 .NH 2
1425 Summary uzbl
1426 .LP
1427 ``Uzbl is a browser that adheres to the Unix Philosophy'',
1428 that is how uzbl is seen by its authors.
1429 Indeed, uzbl follows the Unix Philosophy in many ways.
1430 It consists of independent parts that work together,
1431 its core is mainly a mediator which glues the parts together.
1432 .PP
1433 Software leverage can excellently be seen in uzbl.
1434 It makes use of external tools, separates independent tasks
1435 in independent parts, and glues them together with small
1436 handler scripts, around uzbl-core.
1437 .PP
1438 As uzbl, more or less, consists of a set of tools and a bit
1439 of glue, anyone can put the parts together and expand it
1440 in any desired way.
1441 Uzbl is very flexible and customizable.
1442 These properties make it valuable for advanced users,
1443 but may keep novice users from using it.
1444 .PP
1445 Uzbl's main problem is the modern web, that makes it hard
1446 to design a sane web browser.
1447 Despite this bad situation, uzbl does a fairly good job.
1450 .NH 1
1451 Final thoughts
1453 .NH 2
1454 Quick summary
1455 .LP
1456 good design
1457 .LP
1458 unix phil
1459 .LP
1460 case studies
1462 .NH 2
1463 Why people should choose
1464 .LP
1465 Make the right choice!
1467 .nr PI .5i
1468 .rm ]<
1469 .de ]<
1470 .LP
1471 .de FP
1472 .IP \\\\$1.
1473 \\..
1474 .rm FS FE
1475 ..
1476 .SH
1477 References
1478 .[
1479 $LIST$
1480 .]
1481 .wh -1p