---
product_id: 104516835
title: "A Philosophy of Software Design"
brand: "john ousterhout"
price: "€ 20.40"
currency: EUR
in_stock: true
reviews_count: 8
url: https://www.desertcart.es/products/104516835-a-philosophy-of-software-design
store_origin: ES
region: Spain
---

# A Philosophy of Software Design

**Brand:** john ousterhout
**Price:** € 20.40
**Availability:** ✅ In Stock

## Quick Answers

- **What is this?** A Philosophy of Software Design by john ousterhout
- **How much does it cost?** € 20.40 with free shipping
- **Is it available?** Yes, in stock and ready to ship
- **Where can I buy it?** [www.desertcart.es](https://www.desertcart.es/products/104516835-a-philosophy-of-software-design)

## Best For

- john ousterhout enthusiasts

## Why This Product

- Trusted john ousterhout brand quality
- Free international shipping included
- Worldwide delivery with tracking
- 15-day hassle-free returns

## Description

Full description not available

## Images

![A Philosophy of Software Design - Image 1](https://m.media-amazon.com/images/I/511gE5d3QTL.jpg)

## Customer Reviews

### ⭐ 







  
  
    An OO lover's biased perspective on software design
  

*by H***Y on Reviewed in the United States on September 10, 2018*

This book does not consider functional programming, or the fact that terrible software in modern times is often the result of layers of incorrect abstraction that are often induced by the overuse of "object oriented" (OO) programming techniques.  Instead, it takes OO programming for granted as being a good thing (visible in its preferences for two OO languages, C++ and Java), and then it reasons in that domain, making it totally uninteresting to many potential readers.  The book also assumes that formal design doesn't work (he calls it "waterfall"), and takes alternatives for granted.  I doubt the author is even aware of his inherent bias, but it is incredibly strong.

### ⭐⭐⭐⭐ 







  
  
    Beautifully-written, but with blind spots
  

*by J***L on 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.htmlA 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.

### ⭐⭐ 







  
  
    Perhaps suitable for entry level engineers?
  

*by A***D on Reviewed in the United States on September 11, 2018*

It may be suited for entry entry level engineers, and they find it an interesting read.  I didn't learned anything, I am afraid, and was irritated at times when I disagreed with authors opinion that was being passed off as facts.What bothered me the most is the lack of rigor, for instance, he advocates for incremental design which costs 10-20% and if you don't it will make you 10%-20% slower after some point.  The only motivation a graph with no units.  It may matter if is 10% or 20%, as that is after all a factor of 2.  Also, it's not really clear that once in a while 10% investment, let's call it 45 minutes is a very different cost than a recurring daily 45 minute overhead due to cost being a mess.  I don't have any data to dispute the numbers, btw, but on the other hand, I have not seen any studies to support it either, and the author does not tell us where he is getting this from.His advise of avoiding lots of small functions as it means you will be bouncing all over the place to understand the code is not necessarily wrong.  It adds lots of boiler plate, for example. Using an argument from the book itself, however, you could argue that good names and comments would mean you didn't need to read those lower level functions.  The counter argument is that smaller functions are much easier to unit test.  Then you have the unit test vs integration test discussion of course.There are 3 chapters on comments.  Why?!  I am towards the "good code is self-documenting" end of the spectrum, although I would  say a lot of comments is often (but certainly not always) a code smell that suggest refactoring using better names, extracting code to function etc.  I do like how he describes good comments as either lower or higher level than the code.The text editor example that runs through most of the book becomes trite.  What I find way more interesting is when he talks about his experience with TCL (design mistakes, or the benefits derived from unit test suite), or towards the end RAMCloud and a specific implementation detail.

---

## Why Shop on Desertcart?

- 🛒 **Trusted by 1.3+ Million Shoppers** — Serving international shoppers since 2016
- 🌍 **Shop Globally** — Access 737+ million products across 21 categories
- 💰 **No Hidden Fees** — All customs, duties, and taxes included in the price
- 🔄 **15-Day Free Returns** — Hassle-free returns (30 days for PRO members)
- 🔒 **Secure Payments** — Trusted payment options with buyer protection
- ⭐ **TrustPilot Rated 4.5/5** — Based on 8,000+ happy customer reviews

**Shop now:** [https://www.desertcart.es/products/104516835-a-philosophy-of-software-design](https://www.desertcart.es/products/104516835-a-philosophy-of-software-design)

---

*Product available on Desertcart Spain*
*Store origin: ES*
*Last updated: 2026-02-21*