
Download the free Kindle app and start reading Kindle books instantly on your smartphone, tablet, or computer - no Kindle device required.
Read instantly on your browser with Kindle for Web.
Using your mobile phone camera - scan the code below and download the Kindle app.
Follow the author
OK
A Philosophy of Software Design Paperback – April 6, 2018
This book addresses the topic of software design: how to decompose complex software systems into modules (such as classes and methods) that can be implemented relatively independently. The book first introduces the fundamental problem in software design, which is managing complexity. It then discusses philosophical issues about how to approach the software design process, and it presents a collection of design principles to apply during software design. The book also introduces a set of red flags that identify design problems. You can apply the ideas in this book to minimize the complexity of large software systems, so that you can write software more quickly and cheaply.
- Print length190 pages
- LanguageEnglish
- Publication dateApril 6, 2018
- Dimensions6.5 x 0.43 x 8 inches
- ISBN-101732102201
- ISBN-13978-1732102200
Book recommendations, author interviews, editors' picks, and more. Read it now.
Customers who viewed this item also viewed
- Complexity is anything related to the structure of a software system that makes it hard to understand and modify the system.Highlighted by 2,133 Kindle readers
- One of the most important goals of good design is for a system to be obvious.Highlighted by 1,837 Kindle readers
- Change amplification: The first symptom of complexity is that a seemingly simple change requires code modifications in many different places.Highlighted by 1,658 Kindle readers
Product details
- Publisher : Yaknyam Press; 1st edition (April 6, 2018)
- Language : English
- Paperback : 190 pages
- ISBN-10 : 1732102201
- ISBN-13 : 978-1732102200
- Item Weight : 7.2 ounces
- Dimensions : 6.5 x 0.43 x 8 inches
- Best Sellers Rank: #703,547 in Books (See Top 100 in Books)
- #4,987 in Computer Programming (Books)
- Customer Reviews:
About the author

Discover more of the author’s books, see similar authors, read book recommendations and more.
Customer reviews
Customer Reviews, including Product Star Ratings help customers to learn more about the product and decide whether it is the right product for them.
To calculate the overall star rating and percentage breakdown by star, we don’t use a simple average. Instead, our system considers things like how recent a review is and if the reviewer bought the item on Amazon. It also analyzed reviews to verify trustworthiness.
Learn more how customers reviews work on AmazonCustomers say
Customers find the book concise and easy to understand. They appreciate the clear explanations of ideas and concepts. Many find it concise and small, with practical ways to reduce complexity. The book provides a clear picture of clean and maintainable software that ordinary people can understand. However, some customers feel the book fails to address modern design issues and shows poor design choices.
AI-generated from the text of customer reviews
Customers find the book's ideas and concepts clear. They appreciate the author's explanations and recommendations for resolving design issues. The book is described as concise and ground-breaking in programming.
"...easy-to-read chapters on what the author believes are proper software design practices, primarily for the C/C++ and Java languages...." Read more
"The book is usefull to learn about code best prwctice principles , is a basic book for beginners" Read more
"...The author provdes a very nice clue to whether or not code should be broken out - do you have to keep flipping back and forth between the sub-task..." Read more
"This is a well written, succinct book with lots of good stuff to say on software design...." Read more
Customers find the book concise and easy to understand. They mention it's a good complement to Clean Code, providing guidance on how to reduce complexity. The book is well-written and a basic guide for beginners, diving deep into the essence of good coding patterns.
"This book is comprised of short, easy-to-read chapters on what the author believes are proper software design practices, primarily for the C/C++ and..." Read more
"...of really good advice in this book, and it's explained with clear and concrete examples. I especially enjoyed his sections on comments...." Read more
"...usefull to learn about code best prwctice principles , is a basic book for beginners" Read more
"...Managers should buy it for their teams. It should be required reading for new team members (it doesn't long to get through - a few hours)...." Read more
Customers appreciate the book's conciseness and clarity. They find it small but powerful, with no wasted space.
"This book is comprised of short, easy-to-read chapters on what the author believes are proper software design practices, primarily for the C/C++ and..." Read more
"...Good stuff. It's a short read. You'll scarcely find a book that's so short be so valuable...." Read more
"...Another plus? It's short and sweet. No fluff, no filler—just straight-up wisdom packed into concise sentences...." Read more
"...2. Long methods are OK. Not true for sure. The author says that the long methods can have a few blocks and each block can be understood separately...." Read more
Customers find the book's maintenance recommendations readable, easy to understand, and maintainable by ordinary people. They mention it provides a clear picture of clean and maintainable software without being overly technical.
"...where the languages, tools and targets favor methodical, efficient, maintainable, and extensible code bases. I love this book...." Read more
"...that can help make your software more readable, easy to use and maintainable. How ever a word of caution...." Read more
"...While I liked the recommendation in maintenance, it could have been folded into an earlier chapter in first part...." Read more
"...Software should be simple enough to be understood and maintained by ordinary people. It should be read easily without cognitive burden...." Read more
Customers find the book's design poor. They say it fails to address modern design issues and provides limited abstraction. The examples are written in C++ with poor design choices littering the pages.
"...possible, however, as sometimes it's necessary to build iteratively around poor design (violating the consistency and complexity principles) before..." Read more
"The author has clearly seen many poorly-designed programs, and he reveals many common design flaws...." Read more
"...The book fails to address most modern design issues, examples written in C++ show limited abstraction, and assume you need to be operating at low..." Read more
"...The book also assumes that formal design doesn't work (he calls it "waterfall"), and takes alternatives for granted...." Read more
Reviews with images

A better Alternative to "Clean Code"
Top reviews from the United States
There was a problem filtering reviews right now. Please try again later.
- Reviewed in the United States on January 4, 2019This book is comprised of short, easy-to-read chapters on what the author believes are proper software design practices, primarily for the C/C++ and Java languages. Most of the design practices are relevant for other languages and methodologies (functional, procedural, etc.) as well.
Whether or not you agree with those practices is another question, and based primarily on which coding style camp you fall into. If you're a firm believer in Agile practices, test driven development, self-documenting code, or the latest coding standard fads you will likely take issue with this book. For example, the author prefers 'strategic' software design over 'tactical' design. The former means thinking about where the system is going and writing code that is maintainable and extensible over the long haul, as opposed to the 'tactical' approach of getting a minimal something running as soon as possible. Of course, such advice conflicts with modern practices such as Agile and associated software philosophies such as YAGNI (You Ain't Gonna Need It). If you agree with the author (as I do) and don't care much for some of these 'modern' ideas you'll love this book. On the other hand, if you live and breathe Extreme Programming, code in JavaScript, and believe that any program that takes more than two weeks to write will miss the market window, well, you won't find much to agree with here.
To be fair, I have 40 years of experience in writing software for embedded systems, mostly in C/C++. There really wasn't much in this book that I didn't already know and practice. Like the author, I'm a firm believer in code with lots of well-written comments that document WHY (and not what) the code is doing. Like the author, I find test-driven development clumsy and ineffective. Like the author, I believe that simple interfaces and deep implementations are important, and that small function bodies create bloated, overly-complicated programs with a tendency toward "classitis" (the authors term for too many small classes). In other words, the author's biases match mine, and we both write code in software fields where the languages, tools and targets favor methodical, efficient, maintainable, and extensible code bases. I love this book. A developer writing a front-end for a cloud-based app using a framework-based language, where time-to-market is everything, probably won't.
I recommend this book highly for software engineers who would like to take a break from the latest coding practice du jour and write well-crafted, easily maintainable code for a change.
- Reviewed in the United States on October 29, 2018Since 2016, my job has been to teach software design at the advanced level to professional engineers. I run workshops, speak at tech companies, and blog on software design. So when I heard of this book, I naturally took a look to see if I could recommend it to students.
PoSD is best read as a tactical guide of how-to’s. About a quarter of it is spent on naming and comments, and much of the rest is about specific patterns. His few attempts to jump from tactical advice to principles are either done by trying to blur together similar-sounding tips, or are hamstrung by his inability to see the meaning of a program beyond the code. He demonstrates the lack of principles comically in Chapter 19, where he promises to apply the books’ “principles” to several software trends, and then fills the rest of the chapter with standard (but solid) advice on unit-testing and OOP, with nary a reference to the rest of the book. On the whole, the book’s advice is higher-level than beginner books like Clean Code, but most of its contents will be familiar to a senior software engineer, and the novel parts are hit-and-miss.
A huge underlying theme of the book, and one of its few novel parts, is Ousterhout's idea of deep modules: modules should have an implementation which is simpler than the interface. This sounds elegant, and impossible to argue with. Unfortunately, it's also objectively wrong. Further inspection shows that actually many common abstractions like stacks fail this test, and even Ousterhout's own example of a deep module has an interface which is far more complex than he claims. Overall, Ousterhout misses the deeper notions of complexity, the kind which is about what a piece of code means and how it may be used and how it may be changed, rather than the kind that can be gleaned by glancing at the code. This is a major blindspot which damages the book significantly, and limits his ability to give precise advice.
When Ousterhout tells you do reduce complexity, it often sounds like telling someone going on a date or interview "just be yourself:" the advice only works if you already understand complexity.
Despite that, there is a lot of really good advice in this book, and it's explained with clear and concrete examples. I especially enjoyed his sections on comments. While I don't agree with everything in that section either, there are some really good points that I hope become common practice, and which I have not seen others write about. His chapter on performance engineering is also gold.
So, read the book, savor the advice, but take his justifications with a grain of salt and know that they're not universals, because there are deeper principles to be found.
I wrote a much longer review on my blog, going into these points in more detail. For my full review, see: http://www.pathsensitive.com/2018/10/book-review-philosophy-of-software.html
A Philosophy of Software Design is a good book, but not a great one. But it's one of the only books of its kind out there. Hence, I am proud to recommend it to all junior-level software engineers.
Top reviews from other countries
-
Daniel ConstantinovReviewed in Brazil on May 20, 2024
5.0 out of 5 stars Fantástico !!!
Esse livro é uma rara exceção no mundo de hoje. A didática do autor é fascinante e sua habilidade de transmitir o que realmente importa é notável.
Mudou minha mente como programador e resolveu muitos conflitos que me afligiam.
É um texto conciso, claro e objetivo que todo programador deveria ler (e aplicar).
A lucidez do autor em falar de temas tão comuns aos programadores vem tanto da sua experiência prática como dos seus anos lecionando a matéria, o que é sem dúvida um enorme diferencial na relevância desse texto.
Simplesmente fantástico. Recomendo fortemente !
-
PabloReviewed in Mexico on December 22, 2021
5.0 out of 5 stars Excelente lectura para ingenieros de software
Para mi, un libro indispensable para personas en la industria, pues provee consejos sobre cómo escribir código de calidad
- SimonReviewed in Germany on December 14, 2024
5.0 out of 5 stars This should be #1 and replace "clean code"
I'm a professional software developer with an honored computer science background. This book makes me feel like I'm learning the alphabet again. THIS is how software systems should be written. Not the actual mess you find in nearly any practical project after 3 months or the #1 bestselling "clean code".
The book transports decades of wisdom in writing good code and actually leveraging OOP in practice. Not the inheritance hierarchy mess or compositions of a thousand shallow classes that you'll see everywhere in practice. COMPLEXITY IS THE ENEMY!
All negative reviews do not contradict any of the author's points (content-wise). They simply argue that his book contradicts "Clean Code" by uncle Bob, hence it must be bad. Obviously this is acting like a cult.
"Clean code" is just a mixture of basic advice (good) and logic-contradicting mantras (bad). E.g. "write no comments, instead use method names".
Points I disagree with in the book:
- TDD will not result in fast "feature push-out", much rather it'll emphasize the design-thinking approach, because one has to design the class/method "from the outside".
- Tactical vs. strategic programing is displayed a little black and white for my taste.
- The performance chapter is a bit generic (other than that one must benchmark). For 99% of devs, performance must not be considered, so this chapter should rather be a addendum.
- "Defining errors out of existence" can be practical (then go for it!), but can also result in a huge additional implementation.
- Unit-tests can also hinder "big" refactorings. Because when you change major parts of the system design, those unit tests will not work anymore and must be refactored as well.
- Shabbir DhangotReviewed in India on November 26, 2024
5.0 out of 5 stars Must Read book
Book explains concept really well. This will change your perspective regarding code and help you to improvise your self while writing code.
- Ana Paula Monetti NishimotoReviewed in the Netherlands on November 3, 2024
5.0 out of 5 stars Good book and not a heavy reading
It's an amazing book where you get insights about how to build and maintain a software design. It's technical, but not a heavy reading, which makes it even more enjoyable.