This book is not typical for software literature. An anthology of papers published since 1970s by one of the most influential researchers in software engineering - David Lorge Parnas. Here is a quote from the editors:

---QUOTE---
This book is our attempt to provide a view of the work of one of the grandmasters of our field, highlighting the fundamental ideas that he and his colleagues invented and expounded. We hope to provide the reference for those who teach and those who do, giving them both an historical record, a clear explanation of fundamental ideas that will help them in their work...
---/QUOTE---

Although loosely categorized under 4 parts - Description and specification, Software design, Concurrency and scheduling and Commentary, the papers are effectively assorted. The most influential papers seem to appear in the book, but there also are others that are of interest only with respect to the way the author writes, not with the discussed matter.

To me, the most valuable papers fell into just two categories. First, the ones that I could apply with my practical work (for those who do). Not as a hands-on manual of course, but as the original source of the mechanisms we now have and the goals originally intended. These were papers about modularization, interfaces, abstract data types, handling errors, software "aging" etc. Second were the social and philosophical kind of papers on engineering aspects of software development, professional responsibility and ethics, teaching programming etc (for those who teach).

There also were many papers that I found useless. They either discuss a specific algorithm, or have too much mathematical notation and not enough readable outcome. Mathematical rigor, that I do respect, but having presented a software practitioner with a dense mathematical proof is likely to miss the point. I don't need the proof and I won't be checking it for correctness. I need the result and I will trust it. The author himself writes in one of the papers:

---QUOTE---
Computer professionals do not read our literature because it does not help them to do their job better. These papers may be very good papers, they may have influenced other researchers, but they have not significantly changed the way that programs are written.
---/QUOTE---

Many times I couldn't even read half a page without having my mind drifting away, as the simple idea put in a single sentence brought up a world of thoughts. At that times I had to close the book and stare outside trying to sort out my own thoughts provoked with what I've just read. Many of the things about which Parnas wrote now appear under different names, and they even look and behave slightly different from how he envisioned but it is nevertheless the original source and it is a magnificent feeling to read it.

The book is a great experience to read, but I won't be recommending it to you. You'll know by yourself when you want it.

This book is a must read for anyone taking a course in software design, or software engineers who are interested to design better software systems. The book is not for casual reading, each research paper requires a lot of effort from the reader, to understand and appreciate the depth covered in these papers. It is amazing to find Parnas papers on software engineering, has been tested by time, and has remained undisputed for the last 4 decades. I liked the following papers, criteria used for decomposing system into modules (information hiding), hierarchical software structures, design for ease of extension, program families, and software aging.

I consider this book on two levels:
1. How well does it capture and present the important contributions Parnas has made to the Software Engineering discipline?
2. Is the content (i.e. Parnas' papers) useful?
---

This book does a beautiful job of collecting and organizing Parnas' papers. Each paper is preceeded by an introduction from a peer or other recognized prominent computer scientist. Almost all of these introductions are insightful in themselves: they help create a context for the essay which made it easier for me to fill in the gaps. Almost all of the contributors' writting styles are lucid and easy to read. I found reading through this book quite enjoyable.

Parnas' contributions are critical, no doubt. The concept of Information Hiding as a criteria for modular decomposition really helped form modern "object-oriented" thinking. It seems to me that returning to the first well-formed idea can often grant insights into how to be more effective with its offspring. Indeed, Chapter 7 in this text is essentially a primer on how to think in object-oriented terms.

You'll not find a passage that reads, "now here's an example of that in Java/C#/C++" But that's the blessing: Parnas communicates the essence of the principles that yield quality software engineering without getting lost in unnecessary details. The fact that some of these papers were written 30 years ago helps bring home the fact that novel ideas are rare.

One aspect of 30 year-old writtings that may be a stumbling block for similarly aged programmers is that these works live in an iron world: where programs lived very close to their hardware. Parnas uses phrases like "4 bytes packed in a word" and "core" that seem primal (not to say that some folks aren't concerned with word-sizes and which endian, just that the overall percentage is much lower). For some, this may seem to be a waste of time to try to understand. I encourage the reader to ferret out the bigger message...the more abstract picture of principles that guide one to conceive, organize, implement and document quality software.

If you are a journeyman programmer looking for the original latin, enjoy this well-polished collection for yourself.

Anyone who considers themself a Java developer should know who Dave Parnas is. Without the insight of Dave Parnas in the 60s and 70s there would be no such thing as the Java programming language. Ever heard of information hiding (the basis for all Object Oriented programming)? Yeah, Parnas came up with that. Exception Handling? That's him too. Interfaces? Parnas. (Get the idea?)

This book reprints 33 of Parnas' most influential papers. Each paper is started off with an introduction from one of Parnas' peers (like Barry Boehm), giving the paper a connection to the modern state of Software Engineering, and trying to give the reader an understanding of just how seminal the particular paper was to the world of Computer Science and Software Engineering.

I believe you become a much better programmer if you understand where things come from. Once you understand how things were before "Information Hiding" came about, you get a better appreciation for why its such a necessary and important practice. You'll become a better programmer because you're more aware of what would happen if you didn't have exception handling. And you'll be come a better writer when you understand why buzzwords can be so dangerous in technical papers.

Dave Parnas has been a huge influence over the world of Software Engineering. Everyone should have the chance to read his work.

The ideas presented in this collection of papers changed forever the way I think about developing sofware. These papers separate the men from the boys. If you understand the concepts layed out by Parnas in these papers you are well along your way to understanding the fundamentals necessary for developing quality software. The papers are clearly research oriented and don't have modern real world applications presented in the text, however, the ideas are timeless. The reader will need to make some connections with the modern world on their own. It is well worth the time and effort to read and digest what Parnas has to say.