view @ 7:606f0ffca834

added two more paragraphs to ch02
date Thu, 18 Feb 2010 12:15:39 +0100
parents a6b837d822b7
children 924b2ac2d477
line source
1 .\".if n .pl 1000i
2 .de XX
3 .pl 1v
4 ..
5 .em XX
6 .\".nr PI 0
7 .\".if t .nr PD .5v
8 .\".if n .nr PD 1v
9 .nr lu 0
10 .de CW
11 .nr PQ \\n(.f
12 .if t .ft CW
13 .ie \\$1 .if n .ul 999
14 .el .if n .ul 1
15 .if t .if !\\$1 \&\\$1\f\\n(PQ\\$2
16 .if n .if \\n(.$=1 \&\\$1
17 .if n .if \\n(.$>1 \&\\$1\c
18 .if n .if \\n(.$>1 \&\\$2
19 ..
20 .ds [. \ [
21 .ds .] ]
22 .\"----------------------------------------
23 .TL
24 Why the Unix Philosophy still matters
25 .AU
26 markus schnalke <>
27 .AB
28 .ti \n(.iu
29 This paper discusses the importance of the Unix Philosophy in software design.
30 Today, few software designers are aware of these concepts,
31 and thus most modern software is limited and does not make use of software leverage.
32 Knowing and following the tenets of the Unix Philosophy makes software more valuable.
33 .AE
35 .if t .2C
37 .FS
38 .ps -1
39 This paper was prepared for the seminar ``Software Analysis'' at University Ulm.
40 Mentor was professor Schweiggert. 2010-02-05
41 .br
42 You may get this document from my website
43 .CW \s-1
44 .FE
46 .NH 1
47 Introduction
48 .LP
49 Building a software is a process from an idea of the purpose of the software
50 to its release.
51 No matter \fIhow\fP the process is run, two things are common:
52 the initial idea and the release.
53 The process inbetween can be of any shape.
54 The the maintainance work after the release is ignored for the moment.
55 .PP
56 The process of building splits mainly in two parts:
57 the planning of what and how to build, and implementing the plan by writing code.
58 This paper focuses on the planning part \(en the designing of the software.
59 .PP
60 Software design is the plan of how the internals and externals of the software should look like,
61 based on the requirements.
62 This paper discusses the recommendations of the Unix Philosphy about software design.
63 .PP
64 The here discussed ideas can get applied by any development process.
65 The Unix Philosphy does recommend how the software development process should look like,
66 but this shall not be of matter here.
67 Similar, the question of how to write the code is out of focus.
68 .PP
69 The name ``Unix Philosophy'' was already mentioned several times, but it was not explained yet.
70 The Unix Philosophy is the essence of how the Unix operating system and its toolchest was designed.
71 It is no limited set of rules, but what people see to be common to typical Unix software.
72 Several people stated their view on the Unix Philosophy.
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 for all of them.
107 But there are also points on which they differ.
108 This only underlines what the Unix Philosophy is:
109 A retrospective view on the main concepts of Unix software;
110 especially those that were sucessful and unique to Unix.
111 .\" really?
112 .PP
113 Before we will have a look at concrete concepts,
114 we discuss why software design is important
115 and what problems bad design introduces.
118 .NH 1
119 Importance of software design in general
120 .LP
121 Why should we design software at all?
122 It is general knowledge, that even a bad plan is better than no plan.
123 Ignoring software design is programming without a plan.
124 This will lead pretty sure to horrible results.
125 .PP
126 The design of a software is its internal and external shape.
127 The design talked about here has nothing to do with visual appearance.
128 If we see a program as a car, then its color is of no matter.
129 Its design would be the car's size, its shape, the number and position of doors,
130 the ratio of passenger and cargo transport, and so forth.
131 .PP
132 A software's design is about quality properties.
133 Each of the cars may be able to drive from A to B,
134 but it depends on its properties whether it is a good car for passenger transport or not.
135 It also depends on its properties if it is a good choice for a rough mountain area.
136 .PP
137 Requirements to a software are twofold: functional and non-functional.
138 Functional requirements are easier to define and to verify.
139 They are directly the software's functions.
140 Functional requirements are the reason why software gets written.
141 Someone has a problem and needs a tool to solve it.
142 Being able to solve the problem is the main functional requirement.
143 It is the driving force behind all programming effort.
144 .PP
145 On the other hand, there are also non-functional requirements.
146 They are called \fIquality\fP requirements, too.
147 The quality of a software is about properties that are not directly related to
148 the software's basic functions.
149 Quality aspects are about the properties that are overlooked at first sight.
150 .PP
151 Quality is of few matter when the software gets initially built,
152 but it will be of matter in usage and maintainance of the software.
153 A short-sighted might see in developing a software mainly building something up.
154 Reality shows, that building the software the first time is only a small amount
155 of the overall work.
156 Bug fixing, extending, rebuiling of parts \(en short: maintainance work \(en
157 does soon take over the major part of the time spent on a software.
158 Not to forget the usage of the software.
159 These processes are highly influenced by the software's quality.
160 Thus, quality should never be neglected.
161 The problem is that you hardly ``stumble over'' bad quality during the first build,
162 but this is the time when you should care about good quality most.
163 .PP
164 Software design is not about the basic function of a software;
165 this requirement will get satisfied anyway, as it is the main driving force behind the development.
166 Software design is about quality aspects of the software.
167 Good design will lead to good quality, bad design to bad quality.
168 The primary functions of the software will be affected modestly by bad quality,
169 but good quality can provide a lot of additional gain from the software,
170 even at places where one never expected it.
171 .PP
172 The ISO/IEC 9126-1 standard, part 1,
173 .[
174 %I International Organization for Standarization
175 %T ISO Standard 9126: Software Engineering \(en Product Quality, part 1
176 %C Geneve
177 %D 2001
178 .]
179 defines the quality model as consisting out of:
180 .IP \(bu
181 .I Functionality
182 (suitability, accuracy, inter\%operability, security)
183 .IP \(bu
184 .I Reliability
185 (maturity, fault tolerance, recoverability)
186 .IP \(bu
187 .I Usability
188 (understandability, learnability, operability, attractiveness)
189 .IP \(bu
190 .I Efficiency
191 (time behaviour, resource utilisation)
192 .IP \(bu
193 .I Maintainability
194 (analysability, changeability, stability, testability)
195 .IP \(bu
196 .I Portability
197 (adaptability, installability, co-existence, replaceability)
198 .LP
199 These goals are parts of a software's design.
200 Good design can give these properties to a software,
201 bad designed software will miss them.
202 .PP
203 One further goal of software design is consistency.
204 Consistency eases understanding, working on, and using things.
205 Consistent internals and consistent interfaces to the outside can be provided by good design.
206 .PP
207 We should design software because good design avoids many problems during a software's lifetime.
208 And we should design software because good design can offer much gain,
209 that can be unrelated to the software main intend.
210 Indeed, we should spend much effort into good design to make the software more valuable.
211 The Unix Philosophy shows how to design software well.
212 It offers guidelines to achieve good quality and high gain for the effort spent.
215 .NH 1
216 The Unix Philosophy
217 .LP
218 The origins of the Unix Philosophy were already introduced.
219 This chapter explains the philosophy and shows concrete examples of its application.
221 .SH
222 Examples
223 .LP
224 Following are some examples to demonstrate how applied Unix Philosophy feels like.
225 Knowledge of using the Unix shell is assumed.
226 .PP
227 Counting the number of files in the current directory:
228 .DS
229 .CW
230 ls | wc -l
231 .DE
232 The
233 .CW ls
234 command lists all files in the current directory, one per line,
235 and
236 .CW "wc -l
237 counts how many lines they are.
238 .PP
239 Counting all files that do not contain ``foo'' in their name:
240 .DS
241 .CW
242 ls | grep -v foo | wc -l
243 .DE
244 Here, the list of files is filtered by
245 .CW grep
246 to remove all that contain ``foo''.
247 The rest is the same as in the previous example.
248 .PP
249 Finding the five largest entries in the current directory.
250 .DS
251 .CW
252 du -s * | sort -nr | sed 5q
253 .DE
254 .CW "du -s *
255 returns the recursively summed sizes of all files
256 -- no matter if they are regular files or directories.
257 .CW "sort -nr
258 sorts the list numerically in reverse order.
259 Finally,
260 .CW "sed 5q
261 quits after it has printed the fifth line.
262 .PP
263 The presented command lines are examples of what Unix people would use
264 to get the desired output.
265 There are also other ways to get the same output.
266 It's a user's decision which way to go.
268 .SH
269 Pipes
270 .LP
271 The examples show that a lot of tasks on a Unix system
272 are accomplished by combining several small programs.
273 The connection between the single programs is denoted by the pipe operator `|'.
274 .PP
275 Pipes, and their extensive and easy use, are one of the great
276 achievements of the Unix system.
277 Pipes between programs have been possible in earlier operating systems,
278 but it has never been a so central part of the concept.
279 When, in the early seventies, Doug McIlroy introduced pipes for the
280 Unix system,
281 ``it was this concept and notation for linking several programs together
282 that transformed Unix from a basic file-sharing system to an entirely new way of computing.''
283 .[
284 %T Unix: An Oral History
285 %O .CW \s-1
286 .]
287 .PP
288 Being able to specify pipelines in an easy way is,
289 however, not enough by itself.
290 It is only one half.
291 The other is the design of the programs that are used in the pipeline.
292 They have to be of an external shape that allows them to be be used in such a way.
294 .SH
295 Interface architecture
296 .LP
297 Unix is, first of all, simple: Everything is a file.
298 Files are sequences of bytes, without any special structure.
299 Programs should be filters, which read a stream of bytes from ``standard input'' (stdin)
300 and write a stream of bytes to ``standard output'' (stdout).
301 .PP
302 If our files \fIare\fP sequences of bytes,
303 and our programs \fIare\fP filters on byte streams,
304 then there is exactly one standardized interface.
305 Thus it is possible to combine them in any desired way.
306 .PP
307 Even a handful of small programs will yield a large set of combinations,
308 and thus a large set of different functions.
309 This is leverage!
310 .PP
311 If the programs are orthogonal to each other \(en the best case \(en
312 then the set of different functions is greatest.
313 .PP
314 Now, the Unix toolchest is a set of small programs that
315 are filters on byte streams.
316 They are to a large extend unrelated in their function.
317 Hence, the Unix toolchest provides a large set of functions
318 that can be accessed by combining the programs in the desired way.
320 .SH
321 Advantages of toolchests
322 .LP
323 A toolchest is a set of tools.
324 Instead of having one big tool for all tasks, one has many small tools,
325 each for one task.
326 Difficult tasks are solved by combining several of the small, simple tools.
327 .PP
328 It is easier and less error-prone to write small programs.
329 It is also easier and less error-prone to write a large set of small programs,
330 than to write one large program with all the functionality included.
331 If the small programs are combinable, then they offer even a larger set
332 of functions than the single large program.
333 Hence, one gets two advantages out of writing small, combinable programs.
334 .PP
335 There are two drawbacks of the toolchest approach.
336 First, one simple, standardized, unidirectional Interface has to be sufficient.
337 If one feels the need for more ``logic'' than a stream of bytes,
338 then a different approach might be of need, or, more likely,
339 he just did not came to a design where a stream of bytes is sufficient.
340 The other drawback of a toolchest affects the users.
341 A toolchest is often more difficult to use for novices.
342 It is neccessary to become familiar with each of the tools,
343 to be able to use the right one in a given situation.
344 Additinally, one needs to combine the tools in a senseful way on its own.
345 This is like a sharp knive \(en it is a powerful tool in the hand of a master,
346 but of no good value in the hand of an unskilled.
347 .PP
348 Luckily, the second drawback can be solved easily by adding wrappers around the single tools.
349 Novice users do not need to learn several tools if a professional wraps
350 the single commands into a single script.
351 Note that the wrapper script still calls the small tools;
352 the wrapper script is just like a skin around.
353 No complexity is added this way.
354 .PP
355 A wrapper script for finding the five largest entries in the current directory
356 could look like this:
357 .DS
358 .CW
359 #!/bin/sh
360 du -s * | sort -nr | sed 5q
361 .DE
362 The script itself is just a text file that calls the command line
363 a professional user would type in directly.
370 .NH 2
371 foo
372 .LP
373 standalone vs. tool chain
374 .LP
375 software leverage
376 .LP
377 possiblities
379 .NH 2
380 Results
381 .LP
382 The unix phil is an answer to the sw design question
383 .LP
384 tool chains empower the uses of sw
386 .NH 1
387 Case study: nmh
389 .NH 2
390 History
391 .LP
392 MH, nmh.
393 They are old.
395 .NH 2
396 Contrasts to similar sw
397 .LP
398 vs. Thunderbird, mutt, mailx, pine
399 .LP
400 flexibility, no redundancy, use the shell
402 .NH 2
403 Gains of the design
404 .LP
406 .NH 2
407 Problems
408 .LP
410 .NH 1
411 Case study: uzbl
413 .NH 2
414 History
415 .LP
416 uzbl is young
418 .NH 2
419 Contrasts to similar sw
420 .LP
421 like with nmh
422 .LP
423 addons, plugins, modules
425 .NH 2
426 Gains of the design
427 .LP
429 .NH 2
430 Problems
431 .LP
432 broken web
434 .NH 1
435 Final thoughts
437 .NH 2
438 Quick summary
439 .LP
440 good design
441 .LP
442 unix phil
443 .LP
444 case studies
446 .NH 2
447 Why people should choose
448 .LP
449 Make the right choice!
451 .nr PI .5i
452 .rm ]<
453 .de ]<
454 .LP
455 .de FP
456 .IP \\\\$1.
457 \\..
458 .rm FS FE
459 ..
460 .SH
461 References
462 .[
463 $LIST$
464 .]
465 .wh -1p