A Philosophy of Software Design

I have heard about the book A Philosophy of Software Design by John Ousterhout from one of my other readings. Normally, this gives me some trust and expectation, because if I like the other book, I am very likely to like the referred book as well. Unfortunately, it couldn’t live up to my expectations, and I would rate it as a good, mediocre book.

In the beginning, it started very well. It gave me good context for what the book would be about, such as complexity in software, tactical versus strategic programming, deep versus shallow modules, general-purpose and generalisation, abstractions, and such. I really enjoyed reading until the middle.

At certain points, the author also confronts Robert C. Martin’s famous Clean Code book on certain aspects, for example, how long a method should be. It is very much appreciated; we always need to consider multiple aspects.

Then, right in the middle of the book, several chapters are dedicated to explaining why we should write comments and how to write them. It pushes the topic to extremes, like commenting the members of the classes. There is also a chapter explaining why we should write comments before any code. The book sacrifices more pages to this topic than to anything else, making it a very unbalanced and derailed book. I’m more on Robert C. Martin’s side, and commenting is a last-resort attempt if I’m not able to express myself with code or tests.

The book cannot recover in the end either. It jumps into very important topics, such as consistency, performance, and software trends. But none of those chapters seemed comprehensive enough to me. It’s somewhat of a pity, because the book is less than 200 pages, and adding a few more pages wouldn’t make it lengthy.

What I liked the most:

• The concept of deep versus shallow module
• Thoughts on the complexity

What I didn’t like much:

• Too much focus on commenting
• Incomplete chapters in the second half