Catalogue


The art of UNIX programming /
Eric Steven Raymond.
imprint
Boston, MA : Addison-Wesley, 2004.
description
xxxii, 525 p. : ill.
ISBN
0131429019 (pbk.)
format(s)
Book
Holdings
Subjects
title subject
More Details
imprint
Boston, MA : Addison-Wesley, 2004.
isbn
0131429019 (pbk.)
catalogue key
5342345
 
Includes bibliographical references (p. 483-493) and index.
A Look Inside
About the Author
Author Affiliation
Eric S. Raymond has been a UNIX developer since 1982. He is known as the resident anthropologist and roving ambassador of the open-source community
Excerpts
Introduction or Preface
Preface Unix is not so much an operating system as an oral history. Neal Stephenson There is a vast difference between knowledge and expertise. Knowledge lets you deduce the right thing to do; expertise makes the right thing a reflex, hardly requiring conscious thought at all. This book has a lot of knowledge in it, but it is mainly about expertise. It is going to try to teach you the things about Unix development that Unix experts know, but aren't aware that they know. It is therefore less about technicalia and more about shared culture than most Unix books both explicit and implicit culture, both conscious and unconscious traditions. It is not a 'how-to' book, it is a 'why-to' book. The why-to has great practical importance, because far too much software is poorly designed. Much of it suffers from bloat, is exceedingly hard to maintain, and is too difficult to port to new platforms or extend in ways the original programmers didn't anticipate. These problems are symptoms of bad design. We hope that readers of this book will learn something of what Unix has to teach about good design. This book is divided into four parts: Context, Design, Tools, and Community. The first part (Context) is philosophy and history, to help provide foundation and motivation for what follows. The second part (Design) unfolds the principles of the Unix philosophy into more specific advice about design and implementation. The third part (Tools) focuses on the software Unix provides for helping you solve problems. The fourth part (Community) is about the human-to-human transactions and agreements that make the Unix culture so effective at what it does. Because this is a book about shared culture, I never planned to write it alone. You will notice that the text includes guest appearances by prominent Unix developers, the shapers of the Unix tradition. The book went through an extended public review process during which I invited these luminaries to comment on and argue with the text. Rather than submerging the results of that review process in the final version, these guests were encouraged to speak with their own voices, amplifying and developing and even disagreeing with the main line of the text. In this book, when I use the editorial 'we' it is not to pretend omniscience but to reflect the fact that it attempts to articulate the expertise of an entire community. Because this book is aimed at transmitting culture, it includes much more in the way of history and folklore and asides than is normal for a technical book. Enjoy; these things, too, are part of your education as a Unix programmer. No single one of the historical details is vital, but the gestalt of them all is important. We think it makes a more interesting story this way. More importantly, understanding where Unix came from and how it got the way it is will help you develop an intuitive feel for the Unix style. For the same reason, we refuse to write as if history is over. You will find an unusually large number of references to the time of writing in this book. We do not wish to pretend that current practice reflects some sort of timeless and perfectly logical outcome of preordained destiny. References to time of writing are meant as an alert to the reader two or three or five years hence that the associated statements of fact may have become dated and should be double-checked. Other things this book is not is neither a C tutorial, nor a guide to the Unix commands and API. It is not a reference for sed or yacc or Perl or Python. It's not a network programming primer, nor an exhaustive guide to the mysteries of X. It's not a tour of Unix's internals and architecture, either. Other books cover these specifics better, and this book points you at them as appropriate. Beyond all these technical specifics, the Unix culture has an u
Introduction or Preface
PrefaceUnix is not so much an operating system as an oral history. Neal StephensonThere is a vast difference between knowledge and expertise. Knowledge lets you deduce the right thing to do; expertise makes the right thing a reflex, hardly requiring conscious thought at all.This book has a lot of knowledge in it, but it is mainly about expertise. It is going to try to teach you the things about Unix development that Unix experts know, but aren't aware that they know. It is therefore less about technicalia and more about shared culture than most Unix books both explicit and implicit culture, both conscious and unconscious traditions. It is not a 'how-to' book, it is a 'why-to' book.The why-to has great practical importance, because far too much software is poorly designed. Much of it suffers from bloat, is exceedingly hard to maintain, and is too difficult to port to new platforms or extend in ways the original programmers didn't anticipate. These problems are symptoms of bad design. We hope that readers of this book will learn something of what Unix has to teach about good design.This book is divided into four parts: Context, Design, Tools, and Community. The first part (Context) is philosophy and history, to help provide foundation and motivation for what follows. The second part (Design) unfolds the principles of the Unix philosophy into more specific advice about design and implementation. The third part (Tools) focuses on the software Unix provides for helping you solve problems. The fourth part (Community) is about the human-to-human transactions and agreements that make the Unix culture so effective at what it does.Because this is a book about shared culture, I never planned to write it alone. You will notice that the text includes guest appearances by prominent Unix developers, the shapers of the Unix tradition. The book went through an extended public review process during which I invited these luminaries to comment on and argue with the text. Rather than submerging the results of that review process in the final version, these guests were encouraged to speak with their own voices, amplifying and developing and even disagreeing with the main line of the text.In this book, when I use the editorial 'we' it is not to pretend omniscience but to reflect the fact that it attempts to articulate the expertise of an entire community.Because this book is aimed at transmitting culture, it includes much more in the way of history and folklore and asides than is normal for a technical book. Enjoy; these things, too, are part of your education as a Unix programmer. No single one of the historical details is vital, but the gestalt of them all is important. We think it makes a more interesting story this way. More importantly, understanding where Unix came from and how it got the way it is will help you develop an intuitive feel for the Unix style.For the same reason, we refuse to write as if history is over. You will find an unusually large number of references to the time of writing in this book. We do not wish to pretend that current practice reflects some sort of timeless and perfectly logical outcome of preordained destiny. References to time of writing are meant as an alert to the reader two or three or five years hence that the associated statements of fact may have become dated and should be double-checked.Other things this book is not is neither a C tutorial, nor a guide to the Unix commands and API. It is not a reference for sed or yacc or Perl or Python. It's not a network programming primer, nor an exhaustive guide to the mysteries of X. It's not a tour of Unix's internals and architecture, either. Other books cover these specifics better, and this book points you at them as appropriate.Beyond all these technical specifics, the Unix culture has an u
Introduction or Preface
Preface Unix is not so much an operating system as an oral history.Neal Stephenson There is a vast difference between knowledge and expertise. Knowledge lets you deduce the right thing to do; expertise makes the right thing a reflex, hardly requiring conscious thought at all. This book has a lot of knowledge in it, but it is mainly about expertise. It is going to try to teach you the things about Unix development that Unix experts know, but aren''t aware that they know. It is therefore less about technicalia and more about shared culture than most Unix books both explicit and implicit culture, both conscious and unconscious traditions. It is not a 'how-to' book, it is a 'why-to' book. The why-to has great practical importance, because far too much software is poorly designed. Much of it suffers from bloat, is exceedingly hard to maintain, and is too difficult to port to new platforms or extend in ways the original programmers didn''t anticipate. These problems are symptoms of bad design. We hope that readers of this book will learn something of what Unix has to teach about good design. This book is divided into four parts: Context, Design, Tools, and Community. The first part (Context) is philosophy and history, to help provide foundation and motivation for what follows. The second part (Design) unfolds the principles of the Unix philosophy into more specific advice about design and implementation. The third part (Tools) focuses on the software Unix provides for helping you solve problems. The fourth part (Community) is about the human-to-human transactions and agreements that make the Unix culture so effective at what it does. Because this is a book about shared culture, I never planned to write it alone. You will notice that the text includes guest appearances by prominent Unix developers, the shapers of the Unix tradition. The book went through an extended public review process during which I invited these luminaries to comment on and argue with the text. Rather than submerging the results of that review process in the final version, these guests were encouraged to speak with their own voices, amplifying and developing and even disagreeing with the main line of the text. In this book, when I use the editorial 'we' it is not to pretend omniscience but to reflect the fact that it attempts to articulate the expertise of an entire community. Because this book is aimed at transmitting culture, it includes much more in the way of history and folklore and asides than is normal for a technical book. Enjoy; these things, too, are part of your education as a Unix programmer. No single one of the historical details is vital, but the gestalt of them all is important. We think it makes a more interesting story this way. More importantly, understanding where Unix came from and how it got the way it is will help you develop an intuitive feel for the Unix style. For the same reason, we refuse to write as if history is over. You will find an unusually large number of references to the time of writing in this book. We do not wish to pretend that current practice reflects some sort of timeless and perfectly logical outcome of preordained destiny. References to time of writing are meant as an alert to the reader two or three or five years hence that the associated statements of fact may have become dated and should be double-checked. Other things this book is not is neither a C tutorial, nor a guide to the Unix commands and API. It is not a reference for sed or yacc or Perl or Python. It''s not a network programming primer, nor an exhaustive guide to the mysteries of X. It''s not a tour of Unix''s internals and architecture, either. Other books cover these specifics better, and this book points you at them as appropriate. Beyond all these technical specifics, the Unix culture has an unwritten engineering tradition that has developed over literally millions of man-years1of skilled effort. This book is written in the belief that understanding that tradition, and adding its design patterns to your toolkit, will help you become a better programmer and designer. Cultures consist of people, and the traditional way to learn Unix culture is from other people and through the folklore, by osmosis. This book is not a substitute for person-to-person acculturation, but it can help accelerate the process by allowing you to tap the experience of others. Who Should Read This Book You should read this book if you are an experienced Unix programmer who is often in the position of either educating novice programmers or debating partisans of other operating systems, and you find it hard to articulate the benefits of the Unix approach. You should read this book if you are a C, C++, or Java programmer with experience on other operating systems and you are about to start a Unix-based project. You should read this book if you are a Unix user with novice-level up to middle-level skills in the operating system, but little development experience, and want to learn how to design software effectively under Unix. You should read this book if you are a non-Unix programmer who has figured out that the Unix tradition might have something to teach you. We believe you''re right, and that the Unix philosophy can be exported to other operating systems. So we will pay more attention to non-Unix environments (especially Microsoft operating systems) than is usual in a Unix book; and when tools and case studies are portable, we say so. You should read this book if you are an application architect considering platforms or implementation strategies for a major general-market or vertical application. It will help you understand the strengths of Unix as a development platform, and of the Unix tradition of open source as a development method. You should not read this book if what you are looking for is the details of C coding or how to use the Unix kernel API. There are many good books on these topics;Advanced Programming in the Unix Environmentis classic among explorations of the Unix API, andThe Practice of Programmingis recommended reading for all C programmers (indeed for all programmers in any language). How to Use This Book This book is both practical and philosophical. Some parts are aphoristic and general, others will examine specific case studies in Unix development. We will precede or follow general principles and aphorisms with examples that illustrate them: examples drawn not from toy demonstration programs but rather from real working code that is in use every day. We have deliberately avoided filling the book with lots of code or specification-file examples, even though in many places this might have made it easier to write (and in some places perhaps easier to read!). Most books about programming give too many low-level details and examples, but fail at giving the reader a high-level feel for what is really going on. In this book, we prefer to err in the opposite direction. Therefore, while you will often be invited to read code and specification files, relatively few are actually included in the book. Instead, we point you at examples on the Web. Absorbing these examples will help solidify the principles you learn into semi-instinctive working knowledge. Ideally, you should read this book near the console of a running Unix system, with a Web browser handy. Any Unix will do, but the software case studies are more likely to be preinstalled and immediately available for inspection on a Linux system. The pointers in the book are invitations to browse and experiment. Introduction of these pointers is paced so that wandering off to explore for a while won''t break up exposition that has to be continuous. Note: While we have made every effort to cite URLs that should rem
Introduction or Preface
Preface Unix is not so much an operating system as an oral history.Neal Stephenson There is a vast difference between knowledge and expertise. Knowledge lets you deduce the right thing to do; expertise makes the right thing a reflex, hardly requiring conscious thought at all. This book has a lot of knowledge in it, but it is mainly about expertise. It is going to try to teach you the things about Unix development that Unix experts know, but aren''t aware that they know. It is therefore less about technicalia and more about shared culture than most Unix books both explicit and implicit culture, both conscious and unconscious traditions. It is not a 'how-to' book, it is a 'why-to' book. The why-to has great practical importance, because far too much software is poorly designed. Much of it suffers from bloat, is exceedingly hard to maintain, and is too difficult to port to new platforms or extend in ways the original programmers didn''t anticipate. These problems are symptoms of bad design. We hope that readers of this book will learn something of what Unix has to teach about good design. This book is divided into four parts: Context, Design, Tools, and Community. The first part (Context) is philosophy and history, to help provide foundation and motivation for what follows. The second part (Design) unfolds the principles of the Unix philosophy into more specific advice about design and implementation. The third part (Tools) focuses on the software Unix provides for helping you solve problems. The fourth part (Community) is about the human-to-human transactions and agreements that make the Unix culture so effective at what it does. Because this is a book about shared culture, I never planned to write it alone. You will notice that the text includes guest appearances by prominent Unix developers, the shapers of the Unix tradition. The book went through an extended public review process during which I invited these luminaries to comment on and argue with the text. Rather than submerging the results of that review process in the final version, these guests were encouraged to speak with their own voices, amplifying and developing and even disagreeing with the main line of the text. In this book, when I use the editorial 'we' it is not to pretend omniscience but to reflect the fact that it attempts to articulate the expertise of an entire community. Because this book is aimed at transmitting culture, it includes much more in the way of history and folklore and asides than is normal for a technical book. Enjoy; these things, too, are part of your education as a Unix programmer. No single one of the historical details is vital, but the gestalt of them all is important. We think it makes a more interesting story this way. More importantly, understanding where Unix came from and how it got the way it is will help you develop an intuitive feel for the Unix style. For the same reason, we refuse to write as if history is over. You will find an unusually large number of references to the time of writing in this book. We do not wish to pretend that current practice reflects some sort of timeless and perfectly logical outcome of preordained destiny. References to time of writing are meant as an alert to the reader two or three or five years hence that the associated statements of fact may have become dated and should be double-checked. Other things this book is not is neither a C tutorial, nor a guide to the Unix commands and API. It is not a reference for sed or yacc or Perl or Python. It''s not a network programming primer, nor an exhaustive guide to the mysteries of X. It''s not a tour of Unix''s internals and architecture, either. Other books cover these specifics better, and this book points you at them as appropriate. Beyond all these technical specifics, the Unix culture has an unwritten engineering tradition that has developed over literally millions of man-years1 of skilled effort. This book is written in the belief that understanding that tradition, and adding its design patterns to your toolkit, will help you become a better programmer and designer. Cultures consist of people, and the traditional way to learn Unix culture is from other people and through the folklore, by osmosis. This book is not a substitute for person-to-person acculturation, but it can help accelerate the process by allowing you to tap the experience of others. Who Should Read This Book You should read this book if you are an experienced Unix programmer who is often in the position of either educating novice programmers or debating partisans of other operating systems, and you find it hard to articulate the benefits of the Unix approach. You should read this book if you are a C, C++, or Java programmer with experience on other operating systems and you are about to start a Unix-based project. You should read this book if you are a Unix user with novice-level up to middle-level skills in the operating system, but little development experience, and want to learn how to design software effectively under Unix. You should read this book if you are a non-Unix programmer who has figured out that the Unix tradition might have something to teach you. We believe you''re right, and that the Unix philosophy can be exported to other operating systems. So we will pay more attention to non-Unix environments (especially Microsoft operating systems) than is usual in a Unix book; and when tools and case studies are portable, we say so. You should read this book if you are an application architect considering platforms or implementation strategies for a major general-market or vertical application. It will help you understand the strengths of Unix as a development platform, and of the Unix tradition of open source as a development method. You should not read this book if what you are looking for is the details of C coding or how to use the Unix kernel API. There are many good books on these topics; Advanced Programming in the Unix Environmentis classic among explorations of the Unix API, andThe Practice of Programming is recommended reading for all C programmers (indeed for all programmers in any language). How to Use This Book This book is both practical and philosophical. Some parts are aphoristic and general, others will examine specific case studies in Unix development. We will precede or follow general principles and aphorisms with examples that illustrate them: examples drawn not from toy demonstration programs but rather from real working code that is in use every day. We have deliberately avoided filling the book with lots of code or specification-file examples, even though in many places this might have made it easier to write (and in some places perhaps easier to read!). Most books about programming give too many low-level details and examples, but fail at giving the reader a high-level feel for what is really going on. In this book, we prefer to err in the opposite direction. Therefore, while you will often be invited to read code and specification files, relatively few are actually included in the book. Instead, we point you at examples on the Web. Absorbing these examples will help solidify the principles you learn into semi-instinctive working knowledge. Ideally, you should read this book near the console of a running Unix system, with a Web browser handy. Any Unix will do, but the software case studies are more likely to be preinstalled and immediately available for inspection on a Linux system. The pointers in the book are invitations to browse and experiment. Introduction of these pointers is paced so that wandering off to explore for a while won''t break up exposition that has to be continuous. Note: While we have made every effort to cite URLs that should remain stable and usable, there is no way we can guarantee this. If you find that a cited link has gone stale, use common sense and do a phrase search with your favorite Web search engine. Where possible we suggest ways to do this near the URLs we cite. Most abbreviations used in this book are expanded at first use. For convenience, we have also provided a glossary in an appendix. References are usually by author name. Numbered footnotes are for URLs that would intrude on the text or that we suspect might be perishable; also for asides, war stories, and jokes.2 To make this book more accessible to less technical readers, we invited some non-programmers to read it and identify terms that seemed both obscure and necessary to the flow of exposition. We also use footnotes for definitions of elementary terms that an experienced programmer is unlikely to need. Related References Some famous papers and a few books by Unix''s early developers have mined this territory before. Kernighan and Pike''s The Unix Programming Environment stands out among these and is rightly considered a classic. But today it shows its age a bit; it doesn''t cover the Internet, and the World Wide Web or the new wave of interpreted languages like Perl, Tcl, and Python. About halfway into the composition of this book, we learned of Mike Gancarz''s The Unix Philosophy. This book is excellent within its range, but did not attempt to cover the full spectrum of topics we felt needed to be addressed. Nevertheless we are grateful to the author for the reminder that the very simplest Unix design patterns have been the most persistent and successful ones. The Pragmatic Programmer is a witty and wise disquisition on good design practice pitched at a slightly different level of the software-design craft (more about coding, less about higher-level partitioning of problems) than this book. The authors'' philosophy is an outgrowth of Unix experience, and it is a
First Chapter

Preface

Unix is not so much an operating system as an oral history.—Neal Stephenson

There is a vast difference between knowledge and expertise. Knowledge lets you deduce the right thing to do; expertise makes the right thing a reflex, hardly requiring conscious thought at all.

This book has a lot of knowledge in it, but it is mainly about expertise. It is going to try to teach you the things about Unix development that Unix experts know, but aren't aware that they know. It is therefore less about technicalia and more about shared culture than most Unix books — both explicit and implicit culture, both conscious and unconscious traditions. It is not a ‘how-to’ book, it is a ‘why-to’ book.

The why-to has great practical importance, because far too much software is poorly designed. Much of it suffers from bloat, is exceedingly hard to maintain, and is too difficult to port to new platforms or extend in ways the original programmers didn't anticipate. These problems are symptoms of bad design. We hope that readers of this book will learn something of what Unix has to teach about good design.

This book is divided into four parts: Context, Design, Tools, and Community. The first part (Context) is philosophy and history, to help provide foundation and motivation for what follows. The second part (Design) unfolds the principles of the Unix philosophy into more specific advice about design and implementation. The third part (Tools) focuses on the software Unix provides for helping you solve problems. The fourth part (Community) is about the human-to-human transactions and agreements that make the Unix culture so effective at what it does.

Because this is a book about shared culture, I never planned to write it alone. You will notice that the text includes guest appearances by prominent Unix developers, the shapers of the Unix tradition. The book went through an extended public review process during which I invited these luminaries to comment on and argue with the text. Rather than submerging the results of that review process in the final version, these guests were encouraged to speak with their own voices, amplifying and developing and even disagreeing with the main line of the text.

In this book, when I use the editorial ‘we’ it is not to pretend omniscience but to reflect the fact that it attempts to articulate the expertise of an entire community.

Because this book is aimed at transmitting culture, it includes much more in the way of history and folklore and asides than is normal for a technical book. Enjoy; these things, too, are part of your education as a Unix programmer. No single one of the historical details is vital, but the gestalt of them all is important. We think it makes a more interesting story this way. More importantly, understanding where Unix came from and how it got the way it is will help you develop an intuitive feel for the Unix style.

For the same reason, we refuse to write as if history is over. You will find an unusually large number of references to the time of writing in this book. We do not wish to pretend that current practice reflects some sort of timeless and perfectly logical outcome of preordained destiny. References to time of writing are meant as an alert to the reader two or three or five years hence that the associated statements of fact may have become dated and should be double-checked.

Other things this book is not is neither a C tutorial, nor a guide to the Unix commands and API. It is not a reference for sed or yacc or Perl or Python. It's not a network programming primer, nor an exhaustive guide to the mysteries of X. It's not a tour of Unix's internals and architecture, either. Other books cover these specifics better, and this book points you at them as appropriate.

Beyond all these technical specifics, the Unix culture has an unwritten engineering tradition that has developed over literally millions of man-years1of skilled effort. This book is written in the belief that understanding that tradition, and adding its design patterns to your toolkit, will help you become a better programmer and designer.

Cultures consist of people, and the traditional way to learn Unix culture is from other people and through the folklore, by osmosis. This book is not a substitute for person-to-person acculturation, but it can help accelerate the process by allowing you to tap the experience of others.

Who Should Read This Book

You should read this book if you are an experienced Unix programmer who is often in the position of either educating novice programmers or debating partisans of other operating systems, and you find it hard to articulate the benefits of the Unix approach.

You should read this book if you are a C, C++, or Java programmer with experience on other operating systems and you are about to start a Unix-based project.

You should read this book if you are a Unix user with novice-level up to middle-level skills in the operating system, but little development experience, and want to learn how to design software effectively under Unix.

You should read this book if you are a non-Unix programmer who has figured out that the Unix tradition might have something to teach you. We believe you're right, and that the Unix philosophy can be exported to other operating systems. So we will pay more attention to non-Unix environments (especially Microsoft operating systems) than is usual in a Unix book; and when tools and case studies are portable, we say so.

You should read this book if you are an application architect considering platforms or implementation strategies for a major general-market or vertical application. It will help you understand the strengths of Unix as a development platform, and of the Unix tradition of open source as a development method.

You should not read this book if what you are looking for is the details of C coding or how to use the Unix kernel API. There are many good books on these topics;Advanced Programming in the Unix Environmentis classic among explorations of the Unix API, andThe Practice of Programmingis recommended reading for all C programmers (indeed for all programmers in any language).

How to Use This Book

This book is both practical and philosophical. Some parts are aphoristic and general, others will examine specific case studies in Unix development. We will precede or follow general principles and aphorisms with examples that illustrate them: examples drawn not from toy demonstration programs but rather from real working code that is in use every day.

We have deliberately avoided filling the book with lots of code or specification-file examples, even though in many places this might have made it easier to write (and in some places perhaps easier to read!). Most books about programming give too many low-level details and examples, but fail at giving the reader a high-level feel for what is really going on. In this book, we prefer to err in the opposite direction.

Therefore, while you will often be invited to read code and specification files, relatively few are actually included in the book. Instead, we point you at examples on the Web.

Absorbing these examples will help solidify the principles you learn into semi-instinctive working knowledge. Ideally, you should read this book near the console of a running Unix system, with a Web browser handy. Any Unix will do, but the software case studies are more likely to be preinstalled and immediately available for inspection on a Linux system. The pointers in the book are invitations to browse and experiment. Introduction of these pointers is paced so that wandering off to explore for a while won't break up exposition that has to be continuous.

Note: While we have made every effort to cite URLs that should remain stable and usable, there is no way we can guarantee this. If you find that a cited link has gone stale, use common sense and do a phrase search with your favorite Web search engine. Where possible we suggest ways to do this near the URLs we cite.

Most abbreviations used in this book are expanded at first use. For convenience, we have also provided a glossary in an appendix.

References are usually by author name. Numbered footnotes are for URLs that would intrude on the text or that we suspect might be perishable; also for asides, war stories, and jokes.2

To make this book more accessible to less technical readers, we invited some non-programmers to read it and identify terms that seemed both obscure and necessary to the flow of exposition. We also use footnotes for definitions of elementary terms that an experienced programmer is unlikely to need.

Related References

Some famous papers and a few books by Unix's early developers have mined this territory before. Kernighan and Pike'sThe Unix Programming Environmentstands out among these and is rightly considered a classic. But today it shows its age a bit; it doesn't cover the Internet, and the World Wide Web or the new wave of interpreted languages like Perl, Tcl, and Python.

About halfway into the composition of this book, we learned of Mike Gancarz'sThe Unix Philosophy. This book is excellent within its range, but did not attempt to cover the full spectrum of topics we felt needed to be addressed. Nevertheless we are grateful to the author for the reminder that the very simplest Unix design patterns have been the most persistent and successful ones.

The Pragmatic Programmeris a witty and wise disquisition on good design practice pitched at a slightly different level of the software-design craft (more about coding, less about higher-level partitioning of problems) than this book. The authors' philosophy is an outgrowth of Unix experience, and it is an excellent complement to this book.

The Practice of Programmingcovers some of the same ground asThe Pragmatic Programmerfrom a position deep within the Unix tradition.

Finally (and with admitted intent to provoke) we recommendZen Flesh, Zen Bones, an important collection of Zen Buddhist primary sources. References to Zen are scattered throughout this book. They are included because Zen provides a vocabulary for addressing some ideas that turn out to be very important for software design but are otherwise very difficult to hold in the mind. Readers with religious attachments are invited to consider Zen not as a religion but as a therapeutic form of mental discipline — which, in its purest non-theistic forms, is exactly what Zen is.

Conventions Used in This Book

The term UNIX is technically and legally a trademark of The Open Group, and should formally be used only for operating systems which are certified to have passed The Open Group's elaborate standards-conformance tests. In this book we use Unix in the looser sense widely current among programmers, to refer to any operating system (whether formally Unix-branded or not) that is either genetically descended from Bell Labs's ancestral Unix code or written in close imitation of its descendants. In particular, Linux (from which we draw most of our examples) is a Unix under this definition.

This book employs the Unix manual page convention of tagging Unix facilities with a following manual section in parentheses, usually on first introduction when we want to emphasize that this is a Unix command. Thus, for example, read “munger(1)” as “the ‘munger’ program, which will be documented in section 1 (user tools) of the Unix manual pages, if it's present on your system”. Section 2 is C system calls, section 3 is C library calls, section 5 is file formats and protocols, section 8 is system administration tools. Other sections vary among Unixes but are not cited in this book. For more, typeman 1 manat your Unix shell prompt (older System V Unixes may requireman -s 1 man).

Sometimes we mention a Unix application (such asEmacs), without a manual-section suffix and capitalized. This is a clue that the name actually represents a well-established family of Unix programs with essentially the same function, and we are discussing generic properties of all of them.Emacs, for example, includesxemacs.

At various points later in this book we refer to ‘old school’ and ‘new school’ methods. As with rap music, new-school starts about 1990. In this context, it's associated with the rise of scripting languagesscripting languages, GUIs, open-source Unixes, and the Web. Old-school refers to the pre-1990 (and especially pre-1985) world of expensive (shared) computers, proprietary Unixes, scripting in shell, and C everywhere. This difference is worth pointing out because cheaper and less memory-constrained machines have wrought some significant changes on the Unix programming style.

Our Case Studies

A lot of books on programming rely on toy examples constructed specifically to prove a point. This one won't. Our case studies will be real, pre-existing pieces of software that are in production use every day. Here are some of the major ones:

cdrtools/xcdroastThese two separate projects are usually used together. Thecdrtoolspackage is a set of CLI tools for writing CD-ROMs; Web search for “cdrtools”. Thexcdroastapplication is a GUI front end for cdrtools; see the xcdroast project site <http://www.xcdroast.org/>.fetchmailThefetchmailprogram retrieves mail from remote-mail servers using the POP3 or IMAP post-office protocols. See the fetchmail home page <http://www.catb.org/~esr/fetchmail> (or search for “fetchmail” on the Web).GIMPThe GIMP (GNU Image Manipulation Program) is a full-featured paint, draw, and image-manipulation program that can edit a huge variety of graphical formats in sophisticated ways. Sources are available from the GIMP home page <http://www.gimp.org/> (or search for “GIMP” on the Web).muttThemuttmail user agent is the current best-of-breed among text-based Unix electronic mail agents, with notably good support for MIME (Multipurpose Internet Mail Extensions) and the use of privacy aids such as PGP (Pretty Good Privacy) and GPG (GNU Privacy Guard). Source code and executable binaries are available at the Mutt project site <http://www.mutt.org>.xmltoThexmltocommand renders DocBook and other XML documents in various output formats, including HTML and text and PostScript. For sources and documentation, see the xmlto project site <http://cyberelk.net/ tim/xmlto/>.

To minimize the amount of code the user needs to read to understand the examples, we have tried to choose case studies that can be used more than once, ideally to illustrate several different design principles and practices. For this same reason, many of the examples are from my projects. No claim that these are the best possible ones is implied, merely that I find them sufficiently familiar to be useful for multiple expository purposes.

Author's Acknowledgements

The guest contributors (Ken Arnold, Steven M. Bellovin, Stuart Feldman, Jim Gettys, Steve Johnson, Brian Kernighan, David Korn, Mike Lesk, Doug McIlroy, Marshall Kirk McKusick, Keith Packard, Henry Spencer, and Ken Thompson) added a great deal of value to this book. Doug McIlroy, in particular, went far beyond the call of duty in the thoroughness of his critique and the depth of his contributions, displaying the same care and dedication to excellence which he brought to managing the original Unix research group thirty years ago.

Special thanks go to Rob Landley and to my wife Catherine Raymond, both of whom delivered intensive line-by-line critiques of manuscript drafts. Rob's insightful and attentive commentary actually inspired more than one entire chapter in the final manuscript, and he had a lot to do with its present organization and range; if he had written all the text he pushed me to improve, I would have to call him a co-author. Cathy was my test audience representing non-technical readers; to the extent this book is accessible to people who aren't already programmers, that's largely her doing.

This book benefited from discussions with many other people over the five years it took me to write it. Mark M. Miller helped me achieve enlightenment about threads. John Cowan supplied some insights about interface design patterns and drafted the case studies ofwilyand VM/CMS, and Jef Raskin showed me where the Rule of Least Surprise comes from. The UIUC System Architecture Group contributed useful feedback on early chapters. The sections onWhat Unix Gets WrongandFlexibility in Depthwere directly inspired by their review. Russell J. Nelson contributed the material on Bernstein chaining in Chapter 7. Jay Maynard contributed most of the material in the MVS case study in Chapter 3. Les Hatton provided many helpful comments on the Languages chapter and motivated the portion of on Optimal Module Size. David A. Wheeler contributed many perceptive criticisms and some case-study material, especially in the Design part. Russ Cox helped develop the survey of Plan 9. Dennis Ritchie corrected me on some historical points about C.

Hundreds of Unix programmers, far too many to list here, contributed advice and comments during the book's public review period between January and June of 2003. As always, I found the process of open peer review over the Web both intensely challenging and intensely rewarding. Also as always, responsibility for any errors in the resulting work remains my own.

The expository style and some of the concerns of this book have been influenced by the design patternsdesign patterns movement; indeed, I flirted with the idea of titling the bookUnix Design Patterns. I didn't, because I disagree with some of the implicit central dogmas of the movement and don't feel the need to use all its formal apparatus or accept its cultural baggage. Nevertheless, my approach has certainly been influenced by Christopher Alexander's work3(especiallyThe Timeless Way of BuildingandA Pattern Language), and I owe the Gang of Four and other members of their school a large debt of gratitude for showing me how it is possible to use Alexander's insights to talk about software design at a high level without merely uttering vague and useless generalities. Interested readers should seeDesign Patterns: Elements of Reusable Object-Oriented Softwarefor an introduction to design patterns.

The title of this book is, of course, a reference to Donald Knuth'sThe Art of Computer Programming. While not specifically associated with the Unix tradition, Knuth has been an influence on us all.

Editors with vision and imagination aren't as common as they should be. Mark Taub is one; he saw merit in a stalled project and skillfully nudged me into finishing it. Copy editors with a good ear for prose style and enough ability to improve writing that isn't like theirs are even less common, but Mary Lou Nohr makes that grade. Jerry Votta seized on my concept for the cover and made it look better than I had imagined. The whole crew at Addison-Wesley gets high marks for making the editorial and production process as painless as possible, and for cheerfully accommodating my control-freak tendencies not just over the text but deep into the details of the book's visual design, art, and marketing.

Footnotes

  • The three and a half decades between 1969 and this 2003 is a long time. Going by the historical trend curve in number of Unix sites during that period, probably somewhere upwards of fifty million man-years have been plowed into Unix development worldwide.
  • This particular footnote is dedicated to Terry Pratchett, whose use of footnotes is quite...inspiring.
  • An appreciation of Alexander's work, with links to on-line versions of significant portions, may be found at Some Notes on Christopher Alexander <http://www.math.utsa.edu/ sphere/salingar/Chris.text.html>.
  • Summaries
    Back Cover Copy
    "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 andThinking in C++Writing better software: 30 years of UNIX development wisdomIn 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.
    Back Cover Copy
    "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 andThinking in C++ Writing better software: 30 years of UNIX development wisdom 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.
    Back Cover Copy
    "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++ Writing better software: 30 years of UNIX development wisdom 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.
    Back Cover Copy
    "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 ofExtreme Programming Explained, Test Driven Development, andContributing to Eclipse"A delightful, fascinating read, and the lessons in problem-solvng are essential to every programmer, on any OS." --Bruce Eckel, author ofThinking in JavaandThinking in C++Writing better software: 30 years of UNIX development wisdomIn 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 ofThe Java Programming Language. Steven M. Bellovin, co-creator of Usenet and co-author ofFirewalls and Internet Security. Stuart Feldman, a member of the Bell Labs UNIX development group and the author ofmakeandf77. Jim Gettys and Keith Packard, principal architects of the X windowing system. Steve Johnson, author ofyaccand of the Portable C Compiler. Brian Kernighan, co-author ofThe C Programming Language, The UNIX Programming Environment, The Practice of Programming,and of theawkprogramming language. David Korn, creator of thekornshell and author ofThe New Korn Shell Command and Programming Language. Mike Lesk, a member of the Bell Labs development group and author of themsmacro package, thetblandrefertools,lexandUUCP. 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 createdgetopt, the first open-source string library, and a regular-expression engine used in 4.4BSD.
    Back Cover Copy
    Writing better software: 30 years of UNIX development wisdom 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.
    Bowker Data Service Summary
    This text reveals the software design secrets of the original Unix designers, showing how they produce software that is fast, portable, reuseable, modular and long-lived. Luminaries including Brian Kernighan, David Korn and Henry Spencer contribute to the book.
    Main Description
    bull; bull;Written by Open Source icon Eric S. Raymond - the author of The Cathedral and the Bazaar. bull;Learn how the UNIX masters design software that is fast, portable, reuseable, modular, and long-lived. bull;Includes cameo appearances by UNIX luminaries Brian Kernighan, Doug McIlroy, David Korn, Jim Gettys, Keith Packard, Henry Spencer, Ken Arnold, Mike Lesk, Stuart Feldman and Steve Bellovin.
    Main Description
    bull; Written by Open Source icon Eric S. Raymond - the author of The Cathedral and the Bazaar. bull; Learn how the UNIX masters design software that is fast, portable, reuseable, modular, and long-lived. bull; Includes cameo appearances by UNIX luminaries Brian Kernighan, Doug McIlroy, David Korn, Jim Gettys, Keith Packard, Henry Spencer, Ken Arnold, Mike Lesk, Stuart Feldman and Steve Bellovin.
    Main Description
    Written by Open Source icon Eric S. Raymond - the author of The Cathedral and the Bazaar. bull; Learn how the UNIX masters design software that is fast, portable, reuseable, modular, and long - lived. bull; Includes cameo appearances by UNIX luminaries Brian Kernighan, Doug McIlroy, David Korn, Jim Gettys, Keith Packard, Henry Spencer, Ken Arnold, Mike Lesk, Stuart Feldman and Steve Bellovin.
    Main Description
    - Written by Open Source icon Eric S. Raymond - the author of The Cathedral and the Bazaar. - Learn how the UNIX masters design software that is fast, portable, reuseable, modular, and long-lived. - Includes cameo appearances by UNIX luminaries Brian Kernighan, Doug McIlroy, David Korn, Jim Gettys, Keith Packard, Henry Spencer, Ken Arnold, Mike Lesk, Stuart Feldman and Steve Bellovin.
    Main Description
    & Written by Open Source icon Eric S. Raymond - the author of The Cathedral and the Bazaar. & & Learn how the UNIX masters design software that is fast, portable, reuseable, modular, and long-lived. & & Includes cameo appearances by UNIX luminaries Brian Kernighan, Doug McIlroy, David Korn, Jim Gettys, Keith Packard, Henry Spencer, Ken Arnold, Mike Lesk, Stuart Feldman and Steve Bellovin.
    Main Description
    Written by Open Source icon Eric S. Raymond - the author of The Cathedral and the Bazaar. > Learn how the UNIX masters design software that is fast, portable, reuseable, modular, and long-lived. > Includes cameo appearances by UNIX luminaries Brian Kernighan, Doug McIlroy, David Korn, Jim Gettys, Keith Packard, Henry Spencer, Ken Arnold, Mike Lesk, Stuart Feldman and Steve Bellovin.
    Table of Contents
    Prefacep. xxv
    Contextp. 1
    Philosophy: Philosophy Mattersp. 3
    Culture? What Culture?p. 3
    The Durability of Unixp. 4
    The Case against Learning Unix Culturep. 5
    What Unix Gets Wrongp. 6
    What Unix Gets Rightp. 7
    Basics of the Unix Philosophyp. 11
    The Unix Philosophy in One Lessonp. 25
    Applying the Unix Philosophyp. 26
    Attitude Matters Toop. 26
    History: A Tale of Two Culturesp. 29
    Origins and History of Unix, 1969-1995p. 29
    Origins and History of the Hackers, 1961-1995p. 43
    The Open-Source Movement: 1998 and Onwardp. 49
    The Lessons of Unix Historyp. 51
    Contrasts: Comparing the Unix Philosophy with Othersp. 53
    The Elements of Operating-System Stylep. 53
    Operating-System Comparisonsp. 61
    What Goes Around, Comes Aroundp. 78
    Designp. 81
    Modularity: Keeping It Clean, Keeping It Simplep. 83
    Encapsulation and Optimal Module Sizep. 85
    Compactness and Orthogonalityp. 87
    Software Is a Many-Layered Thingp. 95
    Librariesp. 99
    Unix and Object-Oriented Languagesp. 101
    Coding for Modularityp. 103
    Textuality: Good Protocols Make Good Practicep. 105
    The Importance of Being Textualp. 107
    Data File Metaformatsp. 112
    Application Protocol Designp. 123
    Application Protocol Metaformatsp. 127
    Transparency: Let There Be Lightp. 133
    Studying Casesp. 135
    Designing for Transparency and Discoverabilityp. 148
    Designing for Maintainabilityp. 154
    Multiprogramming: Separating Processes to Separate Functionp. 157
    Separating Complexity Control from Performance Tuningp. 159
    Taxonomy of Unix IPC Methodsp. 160
    Problems and Methods to Avoidp. 176
    Process Partitioning at the Design Levelp. 181
    Minilanguages: Finding a Notation That Singsp. 183
    Understanding the Taxonomy of Languagesp. 185
    Applying Minilanguagesp. 187
    Designing Minilanguagesp. 206
    Generation: Pushing the Specification Level Upwardsp. 215
    Data-Driven Programmingp. 216
    Ad-hoc Code Generationp. 225
    Configuration: Starting on the Right Footp. 231
    What Should Be Configurable?p. 231
    Where Configurations Livep. 233
    Run-Control Filesp. 234
    Environment Variablesp. 238
    Command-Line Optionsp. 242
    How to Choose among the Methodsp. 248
    On Breaking These Rulesp. 252
    Interfaces: User-Interface Design Patterns in the Unix Environmentp. 253
    Applying the Rule of Least Surprisep. 254
    History of Interface Design on Unixp. 256
    Evaluating Interface Designsp. 257
    Tradeoffs between CLI and Visual Interfacesp. 259
    Transparency, Expressiveness, and Configurabilityp. 264
    Unix Interface Design Patternsp. 266
    Applying Unix Interface-Design Patternsp. 280
    The Web Browser as a Universal Front Endp. 281
    Silence Is Goldenp. 284
    Optimizationp. 287
    Don't Just Do Something, Stand There!p. 287
    Measure before Optimizingp. 288
    Nonlocality Considered Harmfulp. 290
    Throughput vs. Latencyp. 291
    Complexity: As Simple As Possible, but No Simplerp. 295
    Speaking of Complexityp. 296
    A Tale of Five Editorsp. 302
    The Right Size for an Editorp. 309
    The Right Size of Softwarep. 316
    Implementationp. 319
    Languages: To C or Not To C?p. 321
    Unix's Cornucopia of Languagesp. 321
    Why Not C?p. 323
    Interpreted Languages and Mixed Strategiesp. 325
    Language Evaluationsp. 325
    Trends for the Futurep. 344
    Choosing an X Toolkitp. 346
    Tools: The Tactics of Developmentp. 349
    A Developer-Friendly Operating Systemp. 349
    Choosing an Editorp. 350
    Special-Purpose Code Generatorsp. 352
    make: Automating Your Recipesp. 357
    Version-Control Systemsp. 364
    Runtime Debuggingp. 369
    Profilingp. 370
    Combining Tools with Emacsp. 370
    Reuse: On Not Reinventing the Wheelp. 375
    The Tale of J. Random Newbiep. 376
    Transparency as the Key to Reusep. 379
    From Reuse to Open Sourcep. 380
    The Best Things in Life Are Openp. 381
    Where to Look?p. 384
    Issues in Using Open-Source Softwarep. 385
    Licensing Issuesp. 386
    Communityp. 391
    Portability: Software Portability and Keeping Up Standardsp. 393
    Evolution of Cp. 394
    Unix Standardsp. 398
    IETF and the RFC Standards Processp. 403
    Specifications as DNA, Code as RNAp. 405
    Programming for Portabilityp. 408
    Internationalizationp. 413
    Portability, Open Standards, and Open Sourcep. 414
    Documentation: Explaining Your Code to a Web-Centric Worldp. 417
    Documentation Conceptsp. 418
    The Unix Stylep. 420
    The Zoo of Unix Documentation Formatsp. 422
    The Present Chaos and a Possible Way Outp. 426
    DocBookp. 427
    Best Practices for Writing Unix Documentationp. 434
    Open Source: Programming in the New Unix Communityp. 437
    Unix and Open Sourcep. 438
    Best Practices for Working with Open-Source Developersp. 440
    The Logic of Licenses: How to Pick Onep. 456
    Why You Should Use a Standard Licensep. 457
    Varieties of Open-Source Licensingp. 457
    Futures: Dangers and Opportunitiesp. 461
    Essence and Accident in Unix Traditionp. 461
    Plan 9: The Way the Future Wasp. 464
    Problems in the Design of Unixp. 466
    Problems in the Environment of Unixp. 473
    Problems in the Culture of Unixp. 475
    Reasons to Believep. 478
    Glossary of Abbreviationsp. 479
    Referencesp. 483
    Contributorsp. 495
    Rootless Root: The Unix Koans of Master Foop. 499
    Indexp. 511
    Table of Contents provided by Ingram. All Rights Reserved.

    This information is provided by a service that aggregates data from review sources and other sources that are often consulted by libraries, and readers. The University does not edit this information and merely includes it as a convenience for users. It does not warrant that reviews are accurate. As with any review users should approach reviews critically and where deemed necessary should consult multiple review sources. Any concerns or questions about particular reviews should be directed to the reviewer and/or publisher.

      link to old catalogue

    Report a problem