UNIX编程艺术（英文影印版）

.ii design
4 modularity: keeping it clean, keeping it simple
4.1 encapsulation and optimal module size
4.2 compactness and orthogonality
4.3 software is a many-layered thing
4.4 libraries
4.5 unix and object-oriented languages
4.6 coding for modularity
5 textuality: good protocols make good practice
5.1 the importance of being textual
5.2 data file metaformats
5.3 application protocol design
5.4 application protocol metaformats
6 transparency: let there be light
6.1 studying cases
6.2 designing for transparency and discoverability
6.3 designing for maintainability
7 multiprogramming: separating processes to separate function
7.1 separating complexity control from performance tuning
7.2 taxonomy of unix ipc methods
7.3 problems and methods to avoid
7.4 process partitioning at the design level
8 minilanguages: finding a notation that sings
8.1 understanding the taxonomy of languages
8.2 applying minilanguages
8.3 designing minilanguages
9 generation: pushing the specification level upwards
9.1 data-driven programming
9.2 ad-hoc code generation
10 configuration: starting on the right foot
10.1 what should be configurable?
10.2 where configurations live ..
10.3 run-control files
10.4 environment variables
10.5 command-line options
10.6 how to choose among the methods
10.7 on breaking these rules
11 interfaces: user-interface design patterns in the unix environment
11.1 applying the rule of least surprise
11.2 history of interface design on unix
11.3 evaluating interface designs
11.4 tradeoffs between cli and visual interfaces
11.5 transparency, expressiveness, and configurability
11.6 unix interface design patterns
11.7 applying unix interface-design patterns
11.8 the web browser as a universal front end
11.9 silence is golden
12 optimization:
13 complexity: as simple as possible, but no simpler
13.1 speaking of complexity
13.2 a tale of five editors
13.3 the right size for an editor
13.4 the right size of software
iii implementation
14 languages: to c or not to c?
15 tools: the tactics of development
15.3 special-purpose code generators
15.4 make: automating your recipes
15.5 version-control systems
15.6 runtime debugging
15.7 profiling
15.8 combining tools with emacs
16 reuse: on not reinventing the wheel
16.1 the tale of j. random newbie
16.2 transparency as the key to reuse
16.3 from reuse to open source
16.4 the best things in life are open
16.5 where to look?
16.6 issues in using open-source software
16.7 licensing issues
iv community
17 portability: software portability and keeping up standards
17.1 evolution of c
17.2 unix standards
17.3 ietf and the rfc standards process
17.4 specifications as dna, code as rna
17.5 programming for portability
17.6 internationalization
17.7 portability, open standards, and open source
18 documentation: explaining your code to a web-centric world
18.1 documentation concepts
18.2 the unix style
18.3 the zoo of unix documentation formats
18.4 the present chaos and a possible way out
18.5 docbook
18.6 best practices for writing unix documentation
19 open source: programming in the new unix community
19.1 unix and open source
19.2 best practices for working with open-source developers
19.3 the logic of licenses: how to pick one
19.4 why you should use a standard license
19.5 varieties of open-source licensing
20 futures: dangers and opportunities
20.1 essence and accident in unix tradition
20.2 plan 9: the way the future was
20.3 problems in the design of unix
20.4 problems in the environment of unix
20.5 problems in the culture of unix
20.6 reasons to believe
a glossary of abbreviations
b references
c contributors
d rootless root: the unix koans of master foo
colophon
index ...