Customer Reviews

Software Tools

5 star:		(6)
4 star:		(1)
3 star:		(0)
2 star:		(2)
1 star:		(0)

 

 

Elsewhere on Amazon I reviewed Kernighan's "Elements of Programming Style." To quote one paragraph from that review -

Brian Kernighan has co-authored three books almost essential to learning our craft, this volume, "Software Tools" and "The Unix Programming Environment". "Elements of Programming Style" spells out the fundamental rules, "Software Tools" shows you how to apply them to a number of simple projects and extends the rules to software design and finally "The Unix Programming Environment" shows you how to use them in an operating system designed to reward you for your effort.

It could be said that "Elements" teaches programming and "Software Tools" teaches software design. Rules such as "do just one thing, do it well" seem to seep in through the pores as you read and work through this book.

It presents a number of projects starting with a word count program and progressing through some filters to some fairly complex tasks culminating in a RatFor pre-processor for Fortran. All the examples are written in RatFor, a version of Fortran that adds some more structured elements to that early language.

Don't be put off by the use of RatFor, the language is easily understood and the style of programming so clear that the algorithms are easily understood. I've personally translated a fair number of them to both BASIC and C and the RatFor pre-processor design became the basis for an AppleSoft BASIC pre-processor written by a close friend.

I've relied on this book so much for the last ten years, after writing "Hello World" I drag it out and translate a couple of the tools into every new language I've learnt. I then spend a day or two thinking about and implementing a design optimised for the new language. After that I find I have a good handle on a language and how to design for it.

This volume is not for those who want a book that gives them pre-written tools, a fair number of the tools are standard issue on any Unix derivative and the code is only tersely commented, relying on the exaplanatory text. However I recommend this book to all software designers and programmers because as you work through these examples you will learn a great deal about honing your craft.

Software Tools. I can't say enough about how important this book was - and still is - to me. The Software Tools in Pascal version does not have the same effect - it doesn't really work. But Software Tools gets across the idea that you do not have to accept the constraints of your environment to produce excellent programs. Instead, develop the program the way is should be and make a surprisingly small effort to then map it to your environment. Don't let the environmental problems constrain your thinking or actual programming. Then with a little effort you can get your environment to match what you need. The book develops a series of software tools, unix style commands, but implements them in a language called RATFOR (Rational Fortran). This is done because Fortran IV was universal at the time, but also horrible as a structured programming language. The delima: Use a better but less widely available language, or use a horrible but very popular and standard language. The author's choice - and the philosophy of the book - don't be boxed in by this choice. They added to Fortran the structures found in C and then wrote a preprocessor to translate this RATFOR to Fortran. The end result was the best of both worlds: well structured programs that will run on just about anything. The whole book is about this kind of choice. It is great philosophy for software development and great philosophy for life. END

The tools you will find in this book are ancient. They're written in a cockeyed hybrid of C and Fortran, and they're almost hilariously user-hostile by modern definitions. If this intimidates you, look at it this way -- you're looking under the hood of modern applications. Much modern word processing, page layout, and language implementation can be built by putting a nice, shiny coating on what you find in this book.

Kernighan and Plauger set out in this book to document what they used in their labs at the time it was written, and show how to build them. Ratfor was chosen because C was not as widespread then as it is now, and for those who didn't have it, a translator to standard Fortran '77 was one of the major parts of the book. A simplified version of the nroff text formatter and a version of ed are also included for text file processing (then as now one of the major uses for computers), the result being both a toolkit and a practical education in the ins and outs of applications development.

The environment given is not Unix-based inherently, but this book is a natural companion to Kernighan and Rob Pike's The Unix Programming Environment and John Lions' Commentary on Unix 6th Edition. It should be required reading for anyone who wants to do software development.

First, I don't have to reintroduce how awesome the author (especially bwk) is. I will just jump to the main topic.

This book, by any means, is better than Code Complete(CC). Don't get me wrong, I am not saying CC is a bad book. To the contrary, CC is a very good book. But this book is still better. Why, here are three reasons.

1. CC is motivated by this book, Software Tools(ST). If you read carefully, you will find that in the preface of CC, it says that "No comparable book is available... some had written 15 years or more earlier ... in Ratfor". Tell you want, it refers to this book(ST). ST deserves a better position than "a 15 years old book in Ratfor", because it handles a even wider topic than CC: how to build practical software. Thus, if you like CC, I will recommend you to this book. If you think CC is verbose, bingo, you have a better choice: this book.

2. ST talks every almost every aspect of programming and tells you how to build into the programming language instead of in the programming language. Think about this, in the FORTRAN years, how to write software not only conquer the complexity of the outside world, but the complicity of the programming language itself. There are tons of books teaches you do Design Pattern, structured programming etc. However, there is no book about how you use your programming language to achieve that. Think about this, JUnit is handy in Java; OO language is handy because they don't need damn pointers around, dynamic type language is handy because you don't need verbose SomeType a = New SomeType() statement. Hardly, you can not find all favorite features in YOUR language. YOUR language usually sucks. (So as mine). There is no silver bullet language. Then, ST teaches you how to use your language to build clean and useful blocks and then get things done. You will finally realize languages will never be your obstacle and you can "import antigravity" to fly (a inner joke, see http://xkcd.com/353/ ). There are two kinds of book, one is by theoretical authors and the other is by the real software engineers. The first kind of book will teach you all kinds of checklist/dogma but you never know how they get used in reality. The second kind of book is like a manual or a tutorial, you can follow it and know what is "structured programming" by practicing it, instead of by "memorizing" it. My kongfu master once told me that you have to learn by acting, not learn by reciting a book.

3. The philosophy in ST is even more valid today, which makes this book even more useful. Think about this, 20 years ago, in Bell Lab, bwk was building C/Unix. His experience was that human time is far more expensive than machine time (He is a scientist) and software should be flexible and code should be readable because you will definitely read it. The experience from Bell Lab is exactly the situation today. (you know, they lead the industry by 20 years, for sure). Human time are far more expensive than machine time and software are subject to change far more often than before. How to handle this? ST provides the answer. You are right, there is no silver bullet, but there is a bullet in ST.

I have been reading this book for several times and still I can get a lot of new stuff from this book every time I read it. Do not miss this classic if you really wants to craft distinguished software, it is the missing manual for you to conquer your stupid programming language. As you know, programming language is and will always be stupid, that's why you need to transform it to be YOUR clear language. Make the transformation today, this is the change you need!

Quite simply, this book was the single greatest influence on my programming abilities. I firmly believe this should be required reading by everyone who wants to learn how to program.

The examples are simple, and you might be tempted to ask yourself why you should write such a simple tool as a word count program, but the examples do a fantastic job of explaining edge cases, performance considerations and all of the other things that separate merely working programs from genuinely good programs.

If you want to learn a little bit of "why" along with your "how", get this book and force yourself to work through all the examples.

I read this book about 20 years back. And I keep quoting it and recommending it, and re-reading it. This is because it changed my whole perspective about writing software. Let me share the two big lessons I learnt.

The first was ego-less programming. Sharing the code and encouraging feedback. We applied this in our group with amazing results. It is a valuable lesson because it is so tough to implement - because of our ego.

The big one was about not writing applications but tools. And creating applications from tools. This lesson kept haunting me whenever I wrote any program. It helped me write generic programs that could be re-used.

The Ratfor examples are a bit dated now. But they elegant and pure.

A must read for all aspire for excellence in coding software.

This book is an excellent introduction to the Unix philosophy and gives a good sense of the development of the Unix tool set on any platform. Unfortunately, the code in this text relies on compiler specific adaptations that were common with Fortran IV processors, but which strict Fortran 66 and 77 compilers are unable to handle, (Fortran 66 compilers are a rarity anymore). This text is only useful as a reference, but is an interesting read, especially in comparing with Software Tools in Pascal and The C Programming Language. If your intent is to learn the software tools with code that can actually compile, get Software Tools in Pascal.

6 pages (145-150) were missing from the copy shipped by Amazon (27th printing). Brian Kernighan and his publisher Pearson were kind to supply both the missing pages and a new copy.

seems a bit dated to me. Not the most relevant book I've owned. It was a pleasure to read, though.

My hopes were high because of the good reviews this book had received... I was disappointed. The idea of many simple programs, each with some clear functionality, that can be combined to produce powerful commands is illustrated clearly enough in the book. But the readability of the code leaves something to be desired. There are lots of if-the-else, while, and repeat constructs, and it's not possible to understand the code without the verbose explanations from the text. Often checking program behaviour for special cases, such as an empty file on input, are not part of the normal text, but left as excercises to the reader.

I would have liked concise comments that state invariants, pre-conditions, and post-conditions to illustrate the correctness of the program. These comments should be part of the program code, not some separate prose that is disconnected from the code. All too often have I had to support code without these comments, and without the accompanying prose to describe the code. This book seems to encourage writing such code.

And also the book is somewhat dated: some of the programs have functionality that made sense in the early days of FORTRAN programming, and are of little use to currentday C/C++ programmers.