- Paperback: 352 pages
- Publisher: Addison-Wesley Professional; 1 edition (January 11, 1976)
- Language: English
- ISBN-10: 020103669X
- ISBN-13: 978-0201036695
- Product Dimensions: 6.2 x 0.8 x 9.2 inches
- Shipping Weight: 1.2 pounds (View shipping rates and policies)
- Average Customer Review: 15 customer reviews
- Amazon Best Sellers Rank: #741,717 in Books (See Top 100 in Books)
To get the free app, enter your mobile phone number.
Software Tools 1st Edition
Use the Amazon App to scan ISBNs and compare prices.
All Books, All the Time
Read author interviews, book reviews, editors picks, and more at the Amazon Book Review. Read it now
Frequently bought together
Customers who bought this item also bought
From the Back Cover
With the same style and clarity that characterized their highly acclaimed book, The Elements of Programming Style, the authors have written Software Tools to teach how to write good programs that make good tools. The programs contained in the book are not artificial, but are actual programs ae tools which have proved valuable in the production of other programs.
Modern programming techniques such as structured programming and top-down design are emphasized and applied to every program. The programs are presented in a structured language called Ratfor ("Rational Fortran") which can be easily understood by anyone familiar with Fortran or PL/I, Algol, PASCAL, or similar languages. (Ratfor translates readily into Fortran or PL/I. One of the tools presented is a preprocessor to translate Ratfor into Fortran). All of the programs are complete and have been tested directly from the text. The programs are available in machine-readable form from Addison-Wesley.
Software Tools is ideal for use in a "software engineering" course, for a second course in programming, or as a supplement in any programming course. All programmers, professional and student, will find the book invaluable as a source of proven, useful programs for reading and study. Numerous exercises are provided to test comprehension and to extend the concepts presented in the text.
About the Author
Brian W. Kernighan works in the Computing Science Research Center at Bell Laboratories, Lucent Technologies. He is Consulting Editor for Addison-Wesley's Professional Computing Series and the author, with Dennis Ritchie, of The C Programming Language.
P.J. Plauger is President of Whitesmiths, Ltd., New York. Dr. Plauger received a Ph.D. in Nuclear Physics from Michigan State University. He is a member of ACM, the American Physical Society, and the Science Fiction Writers of America.
Top customer reviews
This book covers almost every aspect of programming, in the context of writing practical command line tools for UNIX. At that time, FORTRAN was the de facto programming language. There was a big cognitive gap between the programming language at hand (unstructured, messy, low-level), and the programming model in our head (structured, clean, abstract, high-level). To address this problem, the authors proposed to build software "into" the programming language, instead of "in" the programming language. This insight is still valid today, because we still haven't found a programming language that can match the thought pattern of human brain directly. We still have to manually translate our high-level thoughts into low-level program statements. Software engineering about conquering not only the complexity of the outside world (e.g. the inherent complexity of the task that software want to handle), but also the complicity of the programming language itself (e.g. the language itself is not as neat as our thoughts). After all, there is little software engineering concern if the task at hand can be done with a domain-specific language (very high-level usually) in 100 lines. Complexity comes in when we cannot have a language that is high-level enough to match the task at hand, so we need to organize the code to better match the tasks.
The idea of programming into language is so old, yet so new. It was first proposed by the generation of early LISP programmers. They would build their own LISP from ground-up, up till the level where they can use the new LISP to solve the problem. The problem is, your language is not LISP. In fact, your language sucks. I am sure that there are good features in every programming language, but you can hardly find all your favorite language features or high-level constructions/libraries in one language. The fact that there is no silver bullet language calls us to patch up, to enhance our language, until it matches the abstraction level of our mental model, or the tasks at hand.
Software tools is the book that teaches you how to use your language to build clean and useful blocks and then get things done. It does so by building some of the most useful tools in the UNIX programming environment. Once you followed the idea of building into a language, language will not be your obstacle, and all the best practices are in fact ways to enhance the language (e.g. design patterns).
I also enjoy the writing style of this book. There are hands-on examples across the book. There is no checklist/dogma, but examples and tips drawing from those examples. You can get a lot from it if you actually try to build those software tools in C.
Anyway, do not miss this classic if you really wants to craft good software. For me, it is the missing manual for me to conquer my stupid programming language. Programming languages are and will always be stupid, and that's why I need to transform them to be MY language. Using this book to guide that transformation today, and you will be more productive when using your language.