Terra Kaffe - Shop now
Kindle app logo image

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.

QR code to download the Kindle App

Follow the author

Something went wrong. Please try your request again later.

A Philosophy of Software Design Paperback – April 6, 2018

4.5 4.5 out of 5 stars 2,230 ratings

A newer edition of this book is now available; click on "See all formats and editions" above for details.

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.
The%20Amazon%20Book%20Review
The Amazon Book Review
Book recommendations, author interviews, editors' picks, and more. Read it now.
Popular Highlights in this book

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
  • Customer Reviews:
    4.5 4.5 out of 5 stars 2,230 ratings

About the author

Follow authors to get new release updates, plus improved recommendations.
John K. Ousterhout
Brief content visible, double tap to read full content.
Full content visible, double tap to read brief content.

Discover more of the author’s books, see similar authors, read book recommendations and more.

Customer reviews

4.5 out of 5 stars
2,230 global ratings

Review this product

Share your thoughts with other customers

Customers 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

74 customers mention "Clarity"60 positive14 negative

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

74 customers mention "Readability"67 positive7 negative

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

15 customers mention "Shortness"15 positive0 negative

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

6 customers mention "Maintenance"6 positive0 negative

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

4 customers mention "Design"0 positive4 negative

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

A better Alternative to "Clean Code"
5 out of 5 stars
A better Alternative to "Clean Code"
A groundbreaking book in the field of programming that everyone should read as soon as they can understand concepts like SOLID. The author makes use of his experience and understanding of software to the fullest. Anything you've just scarcely noticed or understood naturally over time, John has noticed, understood, identified, named, and studied decades in advance it feels like.
Thank you for your feedback
Sorry, there was an error
Sorry we couldn't load the review

Top reviews from the United States

  • Reviewed in the United States on January 4, 2019
    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 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.
    36 people found this helpful
    Report
  • Reviewed in the United States on October 29, 2018
    Since 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.
    130 people found this helpful
    Report

Top reviews from other countries

Translate all reviews to English
  • Daniel Constantinov
    5.0 out of 5 stars Fantástico !!!
    Reviewed in Brazil on May 20, 2024
    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 !
  • Pablo
    5.0 out of 5 stars Excelente lectura para ingenieros de software
    Reviewed in Mexico on December 22, 2021
    Para mi, un libro indispensable para personas en la industria, pues provee consejos sobre cómo escribir código de calidad
  • Simon
    5.0 out of 5 stars This should be #1 and replace "clean code"
    Reviewed in Germany on December 14, 2024
    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 Dhangot
    5.0 out of 5 stars Must Read book
    Reviewed in India on November 26, 2024
    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 Nishimoto
    5.0 out of 5 stars Good book and not a heavy reading
    Reviewed in the Netherlands on November 3, 2024
    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.