Classics in Software Engineering
Edward Yourdon (editor) (1979)

Book review by Ted Felix

Collection of classic papers from the dawn of structured programming. Much ado about GOTOs. A little dated by today's standards, but mostly fun light reading. Very few people these days need convincing that GOTOs are unnecessary.

Some of the papers are very theoretical and hard to read. Bohm and Jacopini's classic "Flow Diagrams, Turing Machines and Languages with only Two Formation Rules" is one of the harder ones. It proves that you can avoid gotos and instead use while loops and if-then-else structures to implement any program. Ashcroft and Manna's "The Translation of 'go to' Programs to 'while' Programs" is also pretty tough and further shows that the conversion from GOTOs to structures can be automated. Fortunately, Yourdon provides excellent introductions for each paper that summarize the implications, so you can safely skip the difficult ones yet still get a feel for how they affected the industry.

Although the papers are focused on structured programming and the elimination of GOTOs, the beginnings of the Object Oriented revolution are clear in some of the papers like my favorite: D.L. Parnas's "On the Criteria to be Used in Decomposing Systems into Modules".

It appeared to me that in "Structured Programming with go to Statements", Knuth was using the old advertising trick of making the "good" things look better and making the "bad" things look worse. Certain of his code examples are significantly better formatted than others. Those that are better formatted seem to be the ones he prefers in his discussions. Still, the Knuth paper is a very good read as it presents some interesting control structures that haven't made their way into any common programming languages.

Miller and Lindamood's "Structured Programming: Top-Down Approach" explained a number of things that had confused me for years. First, that functions were at one time considered modules. Second, it explained top-down design. This was then followed by Stevens, Myers and Constantine's "Structured Design" which provided a closer look at top-down design using functions as modules. Without these two articles, I still would have had no idea what "Top-Down" design meant. It turns out that this is the approach I was using to design portions of the systems I work on daily, but I had no name for it. Object-Oriented books tend to shy away from adequately explaining this technique (it is, after all, the "competition"). Good software engineers should be familiar with "Top-Down" design as it can sometimes be the best solution for certain problems.

While one might consider the "structured revolution" somewhat dated, there are still programmers out there who would benefit from reading and applying the information found in these papers. Read this book along with McConnell's Code Complete and you'll see where McConnell got much of his information. You can also find a surprising number of these papers online (as evidenced by the above links).

Read from 11/25/2004 to 12/14/2004.

You can try and pick a copy up on Amazon: Classics in Software Engineering but they are very hard to come by. Also try ABEBooks.com. I'm really glad I snapped this one up when I did.

<- Back to my software books page.