Goodreads helps you keep track of books you want to read.
Start by marking “A Philosophy of Software Design” as Want to Read:
A Philosophy of Software Design
Enlarge cover
Rate this book
Clear rating
Open Preview

A Philosophy of Software Design

4.11  ·  Rating details ·  904 ratings  ·  138 reviews
Paperback, 190 pages
Published April 6th 2018 by Yaknyam Press
More Details... Edit Details

Friend Reviews

To see what your friends thought of this book, please sign up.

Reader Q&A

Community Reviews

Showing 1-30
Average rating 4.11  · 
Rating details
 ·  904 ratings  ·  138 reviews

More filters
Sort order
Start your review of A Philosophy of Software Design
César Díez Sánchez
I have mixed feelings in order to rate the book.

First of all, it's worth saying that I wish I had read this book when I was in college or just after starting my professional career. The author has clear and good ideas about how Software should be written properly.

I think this should be a mandatory read for everyone studying computer science, and it should be used as a tool while developing a small project. From a student point of view, I would probably give a 4 or 5 stars review.

I don't consider
Sandro Mancuso
I really enjoyed the first half of the book, when the author discusses complexity, deep vs shallow modules, information hiding, general vs special-purpose interfaces, levels of abstraction, the criteria to split or keep code (methods) together, pull (push?) complexity downwards, and designing errors out of existence. It made me see modularity and complexity in a slightly different way.

The second half of the book is not so great. The emphasis on code comments goes against the idea of Clean Code.
Sep 23, 2018 rated it it was amazing
I really enjoyed reading this book. Ousterhout's book is a very brief book (170 pages), but it builds a thoughtful and solid work about how to design software to avoid complexity.

The book reasonings are a higher level of abstraction than the typical book about software design, however, it also turns to very good specific examples when it's needed.

I liked how the author is able to discover a convincing corpus of interesting principles, practices, reflections and "red flags" about the design of s
Andreea Lucau
Oct 02, 2018 rated it really liked it
We read this book at work for a book club. As someone summarized it - 'it is a short book with several good advice'.
The book offers advice on how to reduce and control complexity in software projects.
I agree with some of the advice, I feel so-so about others. Overall, I recommend it.
Michael Dubakov
Oct 27, 2018 rated it liked it
Shelves: programming
Book with a promising name, but very mixed content. Two good thoughts:

1. Modules should be deep. It is better to have fewer deep modules than more shallow modules
2. The increments of development should be abstractions, not features. When you need an abstraction, invest time and design it clearly

There are many good advices, but on my opinion the book is not deep enough to have this promising title. Also, it's a crime to spend 30 pages of 170 to how to write comments.
Mircea Ŀ
Jan 19, 2019 rated it it was amazing
short. sweet. to the point.

in a world of agile puppets it is refreshing to see someone that takes a no bullshit approach and actually delivers.

i really liked it and i would recommend it to any software developer (orthogonal to how good you think you are or how long you’ve been doing this)
Rodney Norris
I gave this a pretty low rating for me. I still think the book is valuable to read, even though it frustrated me immensely personally.

I whole heartedly agree with the premise that software design is important and as developers we should be focused on reducing complexity. There are plenty of parts in this book I would give 5 stars, but there are others I would easily give 1.

I found this book incredibly polarizing personally. There are times the author comes off as condescending and arrogant. He
Sep 05, 2018 rated it liked it
Very good conversation starter, but very little more. Contains couple of interesting ideas, such as eliminating errors out of existence, however seriously lacks depth. In addition, most of the examples are too simple and rarely stress the importance of a principle. It's still worth reading if you want to start thinking about software design.
Rose Smith
Dec 05, 2019 rated it it was amazing
I think this book is my third time. We read it as part of a book club with mostly book club graduates. Again, a GREAT book. The best part of the book club was the chapter-following discussions!
Sebastian Gebski
Mar 15, 2019 rated it liked it
The farther, the worse. It starts really well, by applying the theory of complexity to software design, but the final chapters felt like the author has no idea what to write about ... So e.g. I loved the idea of deep/shallow modules (I think it's a very visual concept that really helps) or the approach to consistency (and it's really worth emphasizing, because so many Engineers do it wrong), but OTOH after chapter 10-11 there was almost nothing worth mentioning (chapters about comments were lite ...more
Andrew Barchuk
Aug 29, 2018 rated it really liked it
I really like the premise of the book and the topic of software complexity it tries to tackle. There are many ideas that can be refined and fleshed out better. The second edition of the book can be much improved. There're certain approaches that I do not agree with or are not universally true in my opinion. Still the book got me thinking about some important issues which I'm thankful for.
Nov 10, 2018 rated it really liked it
Shelves: development
It's interesting, but it's mostly a summary of topics that you might've already learned somewhere else in other really must-read books.
Jon Kartago Lamida
Jan 02, 2020 rated it really liked it
This book is a good book to complement Code Complete, Clean Code and Working Effectively with Legacy Code. To summarise in one sentence this book is all about managing complexities when writing software. The book is a summary from John Ousterhout course CS 190 Software Design Studio in Standford. That makes all the suggestions in the books although still an opinion but based on learning and feedback settings in the class.

Some concepts are not new and I have read it somewhere else. Some new conce
Aug 01, 2018 rated it really liked it
A short, highly readable book about software design -- primarily at the level of "classes, what they should be like", but with some insights at higher and lower levels of abstraction. Reading this, I found myself generally nodding along and thinking that it was a clear exposition of something I essentially believed.

Ousterhout is a very senior, very successful computer systems researcher and designer. He has the credibility to write a book like this.

A few big ideas that stuck out --
- Ousterhout t
Adil Khashtamov
Oct 14, 2018 rated it really liked it
Short book about good practices on how to reduce code complexity
Mar 03, 2019 rated it it was amazing
I enjoyed this book a lot and I also found James Koppel's book review and the related HN discussion an interesting read. Comparing these two different views I think I agree with the whole "deep modules" idea more. What James described that is "more complicated than the implementation" seems to be a formal software specification to me, which should be way more complex than an interface. And even though there are "plenty of programming languages that do let you write them (the specs) down and chec ...more
May 06, 2019 rated it liked it
This book has some positives, as well as some negatives, and I can't say that I would or wouldn't recommend this book one way or the other - I think it's definitely at least worth a skim, especially since it's pretty compact.

The positives:

+ Good enumeration of what clean, concise code looks like - not a lot of books have this discussion, so it's good to put it out there.
+ Good discussion of code tradeoffs
+A good launching pad to explore other concepts in computer science: pointers, memory lea
Mar 08, 2019 rated it it was amazing
The creator of Tcl is alive and well and teaching CS somewhere. And that is part of what makes this book great - common software design failures are drawn from examples in his classroom, so he is able to explain the reasoning behind a design choice, and then explain how to do it better.

The presentation is much less formal (and shorter) than the usual software design tome, which makes it a quick read.

It's a short book and I didn't find anything I disagree with: it's all really good advice. Ouste
Andrew Bartlett
Feb 19, 2020 rated it really liked it  ·  review of another edition
A seminal work and essential reading for anyone who has been writing code for a good number of years and wants to level up from just "writing code" like any hack amateur, to actually creating thoughtful, well crafted, structured and maintanable software systems.

It promotes good thinking and challenges a lot of misnomers and bad advice you might have heard and unwittingly adopted over the years.

It should probably be subtitled "how to make other developers not hate you and ensure your legacy compr
Mahdi Taghizadeh
Dec 18, 2019 rated it liked it
As stated in the last chapter, this book is about one thing: complexity and of course it's very important in software/system design. Though don't expect a bible for system design but it is worth reading.
Mar 09, 2019 rated it it was amazing
Shelves: 2019
The first part is great. Covers very important fundamentals of software design - complexity: why is it bad, how it manifest itself, how to fight against it. Must read for junior folkes and govnocoders.
Bonus points for 3 long chapters about comments (govnocoders rarely write any comments, The book is good reference to why comments are important )

Chapters 15 - 20 are very basic and useless.
Ruben Paz
Nov 24, 2018 rated it it was amazing
Shelves: tech, favorites
A short book with a bunch of good practices, some I personally disagree with. The majority of the topics covered you've seen them before if you have a couple years of experience in software design.

Nevertheless, a good recommendation for those starting a career in software engineering and a reminder of what we have to deal with for the rest of us.
Hiep Nguyen
Sep 28, 2019 rated it it was amazing
A different point of view in software design. Getting many applicable techniques and tips.
Matt Diephouse
Mar 14, 2019 rated it really liked it
Some portions of this book really resonated with me. I even shared some of them at work. The general approach of constantly investing in the software and improving the design of the system is something I feel very strongly about.

But this book was also a little less than I’d hoped it’d be. I’m not sure it’s at the level where I could share it with a junior engineer: it didn’t have the depth of explanation or the careful walkthrough of application that I’d like to see.
Ondrej Sykora
Mar 01, 2019 rated it really liked it
tl;dr: if you're a software engineer, I strongly recommend reading this book.

The book tries to answer a very complicated and ambiguous question: what is good software design. The main thesis (though perhaps not explicitly stated) is that the quality of the design is strongly correlated with the level of abstraction and the simplicity of interfaces. Whether this is the right definition is debatable, but the author does a good job arguing his case and supporting it with examples.

Two reason why I
Kalecser Kurtz
Aug 03, 2019 rated it it was amazing
Exploring intriguing concepts such as "Define errors out of existence", and "Deep modules"; the book successfully guides the experienced reader through the process of designing systems minimizing complexity.
Sep 11, 2018 rated it it was ok
Shelves: owned-books
Not bad, but I don't get the hype (on Twitter at least) around it.
It's a short read, most of the points are common sense, or fairly obvious. I didn't agree with everything the author wrote, but didn't see anything that made me think "no, you're wrong", more of just "I don't quite agree with this view".
Aug 31, 2019 rated it liked it
This is a kind of tricky book to rate... The advice included is good and worth knowing, but the book discussion itself seems a bit too shallow (and way more academic oriented).

This is a book that you will read quickly, in a couple of hours, and might come out with one or two things stuck to your mind. For example, I particularly liked the discussion regarding tactical approach vs strategical approach to development and I think this is a thing more people should be exposed too, the sooner the bet
Sep 30, 2018 rated it it was amazing
A book very much needed in this time of computing where the essence of design has been ignored or forgotten by so many.
Mansur Mustaquim
Dec 31, 2018 rated it it was ok
This review has been hidden because it contains spoilers. To view it, click here.
« previous 1 3 4 5 next »
There are no discussion topics on this book yet. Be the first to start one »

Readers also enjoyed

  • Designing Data-Intensive Applications
  • The Manager's Path: A Guide for Tech Leaders Navigating Growth and Change
  • An Elegant Puzzle: Systems of Engineering Management
  • Clean Architecture
  • The Pragmatic Programmer: From Journeyman to Master
  • Accelerate: Building and Scaling High-Performing Technology Organizations
  • The Unicorn Project
  • Refactoring: Improving the Design of Existing Code
  • Working Effectively with Legacy Code
  • Building Microservices: Designing Fine-Grained Systems
  • The Software Craftsman: Professionalism, Pragmatism, Pride
  • The Effective Engineer: How to Leverage Your Efforts In Software Engineering to Make a Disproportionate and Meaningful Impact
  • Thinking in Systems: A Primer
  • Software Design Decoded: 66 Ways Experts Think
  • The Mythical Man-Month: Essays on Software Engineering
  • Designing Distributed Systems: Patterns and Paradigms for Scalable, Reliable Services
  • Domain-Driven Design: Tackling Complexity in the Heart of Software
  • Code Complete
See similar books…

Goodreads is hiring!

If you like books and love to build cool products, we may be looking for you.
Learn more »

Related Articles

  Tech pioneer, co-founder of Microsoft, co-chair of the Bill & Melinda Gates Foundation, and author Bill Gates is an avid reader who has ...
493 likes · 137 comments
“Almost every software development organization has at least one developer who takes tactical programming to the extreme: a tactical tornado. The tactical tornado is a prolific programmer who pumps out code far faster than others but works in a totally tactical fashion. When it comes to implementing a quick feature, nobody gets it done faster than the tactical tornado. In some organizations, management treats tactical tornadoes as heroes. However, tactical tornadoes leave behind a wake of destruction. They are rarely considered heroes by the engineers who must work with their code in the future. Typically, other engineers must clean up the messes left behind by the tactical tornado, which makes it appear that those engineers (who are the real heroes) are making slower progress than the tactical tornado.” 1 likes
“Complexity is anything related to the structure of a software system that makes it hard to understand and modify the system.” 0 likes
More quotes…