Amazing Books
Temporary Blank

Monday, October 25, 2010

The Art Of Unix Programming

Art of Unix Programming, The
By Eric Steven Raymond

Publisher : Addison Wesley
Pub Date : September 23, 2003
ISBN : 0-13-142901-9
Pages : 560

"Reading this book has filled a gap in my education. I feel a sense of completion, understand that UNIX is really a style of community. Now I get it, at least I get it one level deeper than I ever did before. This book came at a perfect moment for me, a moment when I shifted from visualizing programs as things to programs as the shadows cast by communities. From this perspective, Eric makes UNIX make perfect sense."
-Kent Beck, author of Extreme Programming Explained, Test Driven Development, and Contributing to Eclipse

"A delightful, fascinating read, and the lessons in problem-solvng are essential to every programmer, on any OS."
-Bruce Eckel, author of Thinking in Java and Thinking in C++

In this book, five years in the making, the author encapsulates three decades of unwritten, hard-won software engineering wisdom. Raymond brings together for the first time the philosophy, design patterns, tools, culture, and traditions that make UNIX home to the world's best and most innovative software, and shows how these are carried forward in Linux and today's open-source movement. Using examples from leading open-source projects, he shows UNIX and Linux programmers how to apply this wisdom in building software that's more elegant, more portable, more reusable, and longer-lived.

Raymond incorporates commentary from thirteen UNIX pioneers:

Ken Thompson, the inventor of UNIX.

Ken Arnold, part of the group that created the 4BSD UNIX releases and co-author of The Java Programming Language.

Steven M. Bellovin, co-creator of Usenet and co-author of Firewalls and Internet Security.

Stuart Feldman, a member of the Bell Labs UNIX development group and the author of make and f77.

Jim Gettys and Keith Packard, principal architects of the X windowing system.

Steve Johnson, author of yacc and of the Portable C Compiler.

Brian Kernighan, co-author of The C Programming Language, The UNIX Programming Environment, The Practice of Programming, and of the awk programming language.

David Korn, creator of the korn shell and author of The New Korn Shell Command and Programming Language.

Mike Lesk, a member of the Bell Labs development group and author of the ms macro package, the tbl and refer tools,lex and UUCP.

Doug McIlroy, Director of the Bell Labs research group where UNIX was born and inventor of the UNIX pipe.

Marshall Kirk McKusick, developer of the 4.2BSD fast filesystem and a leader of the 4.3BSD and 4.4BSD teams.

Henry Spencer, a leader among early UNIX developers, who created getopt, the first open-source string library, and a regular-expression engine used in 4.4BSD.

Addison-Wesley Professional Computing Series
List of Figures
List of Tables
List of Examples
Who Should Read This Book
How to Use This Book
Related References
Conventions Used in This Book
Our Case Studies
Author's Acknowledgements

Part I: Context
Chapter 1. Philosophy: Philosophy Matters
Section 1.1. Culture? What Culture?
Section 1.2. The Durability of Unix
Section 1.3. The Case against Learning Unix Culture
Section 1.4. What Unix Gets Wrong
Section 1.5. What Unix Gets Right
Section 1.6. Basics of the Unix Philosophy
Section 1.7. The Unix Philosophy in One Lesson
Section 1.8. Applying the Unix Philosophy
Section 1.9. Attitude Matters Too

Chapter 2. History: A Tale of Two Cultures
Section 2.1. Origins and History of Unix, 1969–1995
Section 2.2. Origins and History of the Hackers, 1961–1995
Section 2.3. The Open-Source Movement: 1998 and Onward
Section 2.4. The Lessons of Unix History

Chapter 3. Contrasts: Comparing the Unix Philosophy with Others
Section 3.1. The Elements of Operating-System Style
Section 3.2. Operating-System Comparisons
Section 3.3. What Goes Around, Comes Around

Part II: Design
Chapter 4. Modularity: Keeping It Clean, Keeping It Simple
Section 4.1. Encapsulation and Optimal Module Size
Section 4.2. Compactness and Orthogonality
Section 4.3. Software Is a Many-Layered Thing
Section 4.4. Libraries
Section 4.5. Unix and Object-Oriented Languages
Section 4.6. Coding for Modularity

Chapter 5. Textuality: Good Protocols Make Good Practice
Section 5.1. The Impotance of Being Textual
Section 5.2. Data File Metaformats
Section 5.3. Application Protocol Design
Section 5.4. Application Protocol Metaformats

Chapter 6. Transparency: Let There Be Light
Section 6.1. Studying Cases
Section 6.2. Designing for Transparency and Discoverability
Section 6.3. Designing for Maintainability

Chapter 7. Multiprogramming: Separating Processes to Separate Function
Section 7.1. Separating Complexity Control from Performance Tuning
Section 7.2. Taxonomy of Unix IPC Methods
Section 7.3. Problems and Methods to Avoid
Section 7.4. Process Partitioning at the Design Level

Chapter 8. Minilanguages: Finding a Notation That Sings
Section 8.1. Understanding the Taxonomy of Languages
Section 8.2. Applying Minilanguages
Section 8.3. Designing Minilanguages

Chapter 9. Generation: Pushing the Specification Level Upwards
Section 9.1. Data-Driven Programming
Section 9.2. Ad-hoc Code Generation

Chapter 10. Configuration: Starting on the Right Foot
Section 10.1. What Should Be Configurable?
Section 10.2. Where Configurations Live
Section 10.3. Run-Control Files
Section 10.4. Environment Variables
Section 10.5. Command-Line Options
Section 10.6. How to Choose among the Methods
Section 10.7. On Breaking These Rules

Chapter 11. Interfaces: User-Interface Design Patterns in the Unix Environment
Section 11.1. Applying the Rule of Least Surprise
Section 11.2. History of Interface Design on Unix
Section 11.3. Evaluating Interface Designs
Section 11.4. Tradeoffs between CLI and Visual Interfaces
Section 11.5. Transparency, Expressiveness, and Configurability
Section 11.6. Unix Interface Design Patterns
Section 11.7. Applying Unix Interface-Design Patterns
Section 11.8. The Web Browser as a Universal Front End
Section 11.9. Silence Is Golden

Chapter 12. Optimization
Section 12.1. Don't Just Do Something, Stand There!
Section 12.2. Measure before Optimizing
Section 12.3. Nonlocality Considered Harmful
Section 12.4. Throughput vs. Latency

Chapter 13. Complexity: As Simple As Possible, but No Simpler
Section 13.1. Speaking of Complexity
Section 13.2. A Tale of Five Editors
Section 13.3. The Right Size for an Editor
Section 13.4. The Right Size of Software

Part III: Implementation
Chapter 14. Languages: To C or Not To C?
Section 14.1. Unix's Cornucopia of Languages
Section 14.2. Why Not C?
Section 14.3. Interpreted Languages and Mixed Strategies
Section 14.4. Language Evaluations
Section 14.5. Trends for the Future
Section 14.6. Choosing an X Toolkit

Chapter 15. Tools: The Tactics of Development
Section 15.1. A Developer-Friendly Operating System
Section 15.2. Choosing an Editor
Section 15.3. Special-Purpose Code Generators
Section 15.4. make: Automating Your Recipes
Section 15.5. Version-Control Systems
Section 15.6. Runtime Debugging
Section 15.7. Profiling
Section 15.8. Combining Tools with Emacs

Chapter 16. Reuse: On Not Reinventing the Wheel
Section 16.1. The Tale of J. Random Newbie
Section 16.2. Transparency as the Key to Reuse
Section 16.3. From Reuse to Open Source
Section 16.4. The Best Things in Life Are Open
Section 16.5. Where to Look?
Section 16.6. Issues in Using Open-Source Software
Section 16.7. Licensing Issues

Part IV: Community
Chapter 17. Portability: Software Portability and Keeping Up Standards
Section 17.1. Evolution of C
Section 17.2. Unix Standards
Section 17.3. IETF and the RFC Standards Process
Section 17.4. Specifications as DNA, Code as RNA
Section 17.5. Programming for Portability
Section 17.6. Internationalization
Section 17.7. Portability, Open Standards, and Open Source

Chapter 18. Documentation: Explaining Your Code to a Web-Centric World
Section 18.1. Documentation Concepts
Section 18.2. The Unix Style
Section 18.3. The Zoo of Unix Documentation Formats
Section 18.4. The Present Chaos and a Possible Way Out
Section 18.5. DocBook
Section 18.6. Best Practices for Writing Unix Documentation

Chapter 19. Open Source: Programming in the New Unix Community
Section 19.1. Unix and Open Source
Section 19.2. Best Practices for Working with Open-Source Developers
Section 19.3. The Logic of Licenses: How to Pick One
Section 19.4. Why You Should Use a Standard License
Section 19.5. Varieties of Open-Source Licensing

Chapter 20. Futures: Dangers and Opportunities
Section 20.1. Essence and Accident in Unix Tradition
Section 20.2. Plan 9: The Way the Future Was
Section 20.3. Problems in the Design of Unix
Section 20.4. Problems in the Environment of Unix
Section 20.5. Problems in the Culture of Unix
Section 20.6. Reasons to Believe

Appendix A. Glossary of Abbreviations
Appendix B. References
Appendix C. Contributors
Appendix D. Rootless Root: The Unix Koans of Master Foo
Editor's Introduction
Master Foo and the Ten Thousand Lines
Master Foo and the Script Kiddie
Master Foo Discourses on the Two Paths
Master Foo and the Methodologist
Master Foo Discourses on the Graphical User Interface
Master Foo and the Unix Zealot
Master Foo Discourses on the Unix-Nature
Master Foo and the End User


Another Linux Books
Another Open Source Books

No comments:

Post a Comment

Related Posts with Thumbnails
There was an error in this gadget

Put Your Ads Here!
There was an error in this gadget