--- product_id: 345169279 title: "A Philosophy of Software Design, 2nd Edition" price: "185.81 DT" currency: TND in_stock: true reviews_count: 13 url: https://www.desertcart.tn/products/345169279-a-philosophy-of-software-design-2nd-edition store_origin: TN region: Tunisia --- # A Philosophy of Software Design, 2nd Edition **Price:** 185.81 DT **Availability:** ✅ In Stock ## Quick Answers - **What is this?** A Philosophy of Software Design, 2nd Edition - **How much does it cost?** 185.81 DT with free shipping - **Is it available?** Yes, in stock and ready to ship - **Where can I buy it?** [www.desertcart.tn](https://www.desertcart.tn/products/345169279-a-philosophy-of-software-design-2nd-edition) ## Best For - Customers looking for quality international products ## Why This Product - Free international shipping included - Worldwide delivery with tracking - 15-day hassle-free returns ## Description 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. Review: Worth reading, and discussing with your team. - This book is clear, concise, and avoids padding for the sake of page count. This mirrors how the author advocates that software should be designed: minimize complexity, and pursue simplicity. The book lays out many strategies to achieve this goal, while also explaining how one approach reinforces and strengthens another. I found some of the examples to feel a bit academic, yet most do a good job of clarifying the concept being supported. The author has also offered rebuttals for many of the common reasons developers underinvest in software design, which hopefully helps readers confront their internalized self-bargaining techniques (some of which can be seen by reading other reviews here). My primary criticism is that I had hoped for a chapter or two about how to approach a poorly designed system and move it toward a clean design. There's really only a few spots where even needing to make a trade-off like this is recognized, and the most prominent ends with the proposed solution being to ship the feature on the deadline and ask for refactor time in the future. This almost never happens, since there's always another deadline on the horizon. Another place where the problem is briefly acknowledged makes the argument to always leave code with a better design than it was found in. This isn't always possible, however, as sometimes it's necessary to build iteratively around poor design (violating the consistency and complexity principles) before being able to eliminate it. In other words, on a large system, it's sometimes necessary to make a mess even messier before you can clean it up. I'd love to read the author's perspective on this facet of software design, and how to reason through such trade-offs. That said, given that my main critique is that I'd like to hear even more from the author on the topic of software design, I can easily recommend this book to every professional, or aspiring, software engineer. For more senior folks, it'll likely be a crystallization of wisdom you've already learned, in a form that'll be easier for you to socialize with the rest of your team. I, for one, would love to work on any team where the contents of this book are really internalized and applied. Review: An open guide to the fundamentals of coding - Writing computer code provides a programmer incredible freedom, but writing good code that'll work in a team environment is a trickier assignment. Many coders fall back on whatever guidelines their manager issues, but that approach can obscure the real challenge. Not only is someone programming a computer to achieve a certain goal, but that person is simultaneously writing a letter to their future self and fellow programmers about what they are trying to do. Clear communication is as much a part of the challenge as getting the code to work in a maintainable fashion. In this book, John Ousterhout of Stanford University guides newer and mid-career programmers how to write better code. Computer programmers can be famously inflexible with personal coding standards. Whether one agrees with Ousterhout on ever issue or not - I certainly didn't - reading about others' understanding of coding increases your tolerance of other programmers. It simply makes you a better teammate. We all need better teammates, and it starts with you and me personally. He hits on all the major issues good programmers talk about with each other: when to write comments, how to construct self-documenting code, how to design deeply effective classes, and more. These are not challenges that are mastered once-and-for-all; rather, they are daily challenges with each programming assignment. Even as someone who has been programming for decades, he helped me see my craft in small, new ways. The obvious market for a book like this are newer and mid-career programmers. But advanced programmers often benefit from reviewing the main themes from a master craftsperson; indeed, at the very least, they can learn how to express themselves to their mentees. I slowly skimmed this book but slowed down for thoughts that I may not have had explored before. Coders of every ilk like learning by doing, but learning-by-doing has to be supplemented by coaching. Most supervisors don't have the time to do that in depth, so reading books about coding becomes essential. This one should certainly be on the reading list. ## Technical Specifications | Specification | Value | |---------------|-------| | Best Sellers Rank | #2,881 in Books ( See Top 100 in Books ) #1 in Software Development (Books) #1 in Microsoft Programming (Books) #6 in Business Technology | | Customer Reviews | 4.5 out of 5 stars 2,656 Reviews | ## Images ![A Philosophy of Software Design, 2nd Edition - Image 1](https://m.media-amazon.com/images/I/711Qnv05eTL.jpg) ## Customer Reviews ### ⭐⭐⭐⭐⭐ Worth reading, and discussing with your team. *by K***H on February 14, 2023* This book is clear, concise, and avoids padding for the sake of page count. This mirrors how the author advocates that software should be designed: minimize complexity, and pursue simplicity. The book lays out many strategies to achieve this goal, while also explaining how one approach reinforces and strengthens another. I found some of the examples to feel a bit academic, yet most do a good job of clarifying the concept being supported. The author has also offered rebuttals for many of the common reasons developers underinvest in software design, which hopefully helps readers confront their internalized self-bargaining techniques (some of which can be seen by reading other reviews here). My primary criticism is that I had hoped for a chapter or two about how to approach a poorly designed system and move it toward a clean design. There's really only a few spots where even needing to make a trade-off like this is recognized, and the most prominent ends with the proposed solution being to ship the feature on the deadline and ask for refactor time in the future. This almost never happens, since there's always another deadline on the horizon. Another place where the problem is briefly acknowledged makes the argument to always leave code with a better design than it was found in. This isn't always possible, however, as sometimes it's necessary to build iteratively around poor design (violating the consistency and complexity principles) before being able to eliminate it. In other words, on a large system, it's sometimes necessary to make a mess even messier before you can clean it up. I'd love to read the author's perspective on this facet of software design, and how to reason through such trade-offs. That said, given that my main critique is that I'd like to hear even more from the author on the topic of software design, I can easily recommend this book to every professional, or aspiring, software engineer. For more senior folks, it'll likely be a crystallization of wisdom you've already learned, in a form that'll be easier for you to socialize with the rest of your team. I, for one, would love to work on any team where the contents of this book are really internalized and applied. ### ⭐⭐⭐⭐ An open guide to the fundamentals of coding *by S***N on April 10, 2026* Writing computer code provides a programmer incredible freedom, but writing good code that'll work in a team environment is a trickier assignment. Many coders fall back on whatever guidelines their manager issues, but that approach can obscure the real challenge. Not only is someone programming a computer to achieve a certain goal, but that person is simultaneously writing a letter to their future self and fellow programmers about what they are trying to do. Clear communication is as much a part of the challenge as getting the code to work in a maintainable fashion. In this book, John Ousterhout of Stanford University guides newer and mid-career programmers how to write better code. Computer programmers can be famously inflexible with personal coding standards. Whether one agrees with Ousterhout on ever issue or not - I certainly didn't - reading about others' understanding of coding increases your tolerance of other programmers. It simply makes you a better teammate. We all need better teammates, and it starts with you and me personally. He hits on all the major issues good programmers talk about with each other: when to write comments, how to construct self-documenting code, how to design deeply effective classes, and more. These are not challenges that are mastered once-and-for-all; rather, they are daily challenges with each programming assignment. Even as someone who has been programming for decades, he helped me see my craft in small, new ways. The obvious market for a book like this are newer and mid-career programmers. But advanced programmers often benefit from reviewing the main themes from a master craftsperson; indeed, at the very least, they can learn how to express themselves to their mentees. I slowly skimmed this book but slowed down for thoughts that I may not have had explored before. Coders of every ilk like learning by doing, but learning-by-doing has to be supplemented by coaching. Most supervisors don't have the time to do that in depth, so reading books about coding becomes essential. This one should certainly be on the reading list. ### ⭐⭐⭐⭐⭐ Just read it. It's short. It's great. *by M***S on November 10, 2019* I think every person who has written a fair amount of code should read this book. 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). It is NOT for beginner programmers in my mind - you will not have written enough code to understand the points being made. I'd say it's perfect for mid-level to advanced programmers. Why for advanced? Because they can quickly get throught it, and challenge some of their own design assumptions and practices. Mid-level programmers will find it a treasure. The title of the book is perfect, because it really is more philosophical and high-level. But that doesn't mean it's abstract nor boring. I find the ideas very applicable and easy to understand. The opening statements are very powerful - what is complexity, the difference kinds of complexity ("cognitive load" is an excellent concept), etc. It ends with a gem - you know your code is complex if you end up spending a lot of time fixing bugs in it. Complexity begets complexity. Don't let the critical reviews stop you from reading this book - so what, it ignores functional programming. Readers can buy books on that and contrast the desgin philosphy. Yes, it's OOP-based, but so what? It's easy to apply these ideas to non-OOP languages or concepts. Some complained about "3 chapters on comments alone". Not true - the three chapters cover different subjects, and provide excellent guidelines for commenting first (designing with your comments - kind of like writing a mini-spec, if you will), what constitutes a useful comment, and how to name variables. I found it very useful. The concept of "deep" versus "shallow" classes is very interesting, even if some of the reviews have criticized it. 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 and the original function? Maybe it shouldn't have been broken out. Deep classes have simple interfaces and accomplish a lot for the caller. Shallow classes, on the other hand, require the caller to know about them, how to call them in order, etc. Good stuff. It's a short read. You'll scarcely find a book that's so short be so valuable. You can get through it in about 3-4 intense, focused sessions. ## Frequently Bought Together - A Philosophy of Software Design, 2nd Edition - The Pragmatic Programmer: Your Journey To Mastery, 20th Anniversary Edition (2nd Edition) - Designing Data-Intensive Applications: The Big Ideas Behind Reliable, Scalable, and Maintainable Systems --- ## 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.tn/products/345169279-a-philosophy-of-software-design-2nd-edition](https://www.desertcart.tn/products/345169279-a-philosophy-of-software-design-2nd-edition) --- *Product available on Desertcart Tunisia* *Store origin: TN* *Last updated: 2026-05-07*