A Philosophy of Software Design, 2nd Edition

I discovered this work by first watching John present his material at a Google Talk series on software design. When he said he had tried for years to find a book that encapsulated key software design principles and failed, I really resonated with his approach. I have been looking for ages for a standard text to refer to my mentees, and this book really encapsulates all the key design principles I have spent years fine tuning myself. I wish I had had this book when I was starting out! I particularly like John's writing style, it is as clear and concise as the software design principles he advocates. The Book is a print on demand book with a simple but effective design, printed on quality paper. I read it from end to end in a week of lunchtimes, because each chapter focuses on one design principle and is only a few pages long, and while there are small examples for everything, it is not over cluttered with intricate detail. It is just the right level for a beginner or an expert to benefit from alike. The examples are well chosen from a knowledge-base of hundreds of student and industrial projects that John has direct involvement with, and every example clearly supports the principle being presented. I will be recommending this book to everyone that I mentor and support, and I recommend that you buy it too. If you are a beginner, it will give you much to think about and practice as you grow into your career. If you have been developing software for a few years, it will make you re think some of the things you do and adjust your style for the better. If you are experienced, it will encapsulate succinctly all the principles you have spent years perfecting, and give you an easy way to pass on these principles to those around you that you mentor.

A book that falls in the same category as "clean code", except it gives better advice with actual justifications. Unlike "clean code", this book actually tells you why a certain way is better rather than just stating it as some biblical truth. It also presents overarching theory that all the concepts sit on and with which you can take to make actually day to day decisions that aren't based on hard rules. The main concept presented is the idea of complexity, reducing the complexity that is exposed to developers by abstracting it away into parts that can be used as a black box and is seen by few. The book is good for both junior and senior engineers and will make you rethink how you and your team work, in particular constantly improving the code base rather than just looking to address tech debt at some future point in time. At the very least you will come out with a different opinion on some topics, refreshed some good practices, and learn good terminology to describe difficult concepts. People who complain that this book encourages long functions and classes really miss the point. The point is that functions and classes should do one thing in isolation. That's the goal, not to make it short. A lot of the time functions are shorter as a result of following that objective, but you are optimizing for things doing one thing not shortness within itself. Separating functions out into blocks that do nott stand alone as independent units just makes things harder to understand and read as you have to jump about in the file, or into other files. If you look at some of the before and after examples that do this in clean code, they are actually worse a lot of the time after. If you have this opinion, when you read this book be open to changing your mind. If your argument is "functions should be 20 lines long at most because that's what I read in clean code and anything else is wrong" you are really limiting yourself and hurting the people who read your code. It was also very refreshing to finally hear a counter argument to the dogmatic application of TDD. To conclude, if you would like to learn how to write clean code with actual generalisable theory over using hard rules such as never comment, a function should be x lines long, and classes should be y lines long, then this is the book for you.

The book covers some good engineering practises for software design. It is refreshing to see that many views I have held for years is shared by the author as well. for e.g.: I always thought Java IO libraries were bit over engineered and could have been made simpler, glad to see author also shares the same view. Views on design patterns overuse or on TDD , I fully agree. I find it hard to go with the suggestion of designing general solution all the time. Though I agree with the overall concept, designing a generic solution first, will put too much burden on the engineer (who need not be domain expert), as result will end up with wrong or abstraction (most of the time!).

Probably the best general software design book I've ever read. Condenses everything I've been struggling to express about design over 35 years in the IT industry. I wish more junior developers would read this. Comments in code are indispensable. Small methods aren't always good. Lots of very sound, carefully reasoned practical advice here. Deep general purpose modules with small interfaces, well documented. Sadly most code is written once, quickly, in a tactical fashion, then ignored while people move on to newer things. A refreshing change from the "Uncle Bob " dogma. Thoroughly recommended.

the advice presented in this book is generally good but its too generic. it feels like the author has a lot of academic experience and not as much real world (building real apps for production). the advice on comments its just bad. comments for every variable, method, class, module, etc is not realistic. and the examples given with a variable name having a 4 lines comment is something hope to never see on my projects. lastly, i wish he would have placed more emphasis on testing.

The author is not afraid to go against the common idioms of "good design" and he defines a new way to look at problem decomposition and abstractions. The way developers get thought to design systems in conjunction with software development trends too often leads to creating over-complicated software. Any software which is too complex to maintain will eventually be rewritten. The author explains a different approach on how to decompose problems and he defines a methodology to achieve optimal results over time. It also provides a list of red flags which, when found in a software project, enables the developer to timely recognize and correct design issues before they go out of hands. I'd recommend this book to the seasoned developer or software architect who has already seen a number of projects and designed a few systems. Which such experience the reader will quickly recognize many of the bad ways to design a system and the type of problems which bad design leads to.

John writes about some of the software design principles that contradict with principles favoured by Robert C. Martin. Some principles may be an opposite to what we've been thought. e.g deep modules, general-purpose interfaces, TDD effecting design, comments etc. Many of his findings are based on teaching students at Stanford. However, does it still apply for experience engineers who can make special-purpose interfaces, they are used to high cognitive load, perform TDD and good design at the same time, design once, because they know this is the best approach beforehand etc? I think it does apply, because as John mentioned in his book, "software should be designed for ease of reading, not ease of writing".

I'm stuck between 3 and 4 stars. As others said, it's a good book overall. There are some design principles that make a lot of sense and also, in retrospective, explain why some Java libraries are so bad ( you can figure it out for yourself after reading it ). However, I couldn't get over the fact that a substantial part of this book is mostly about comments - got to a point where I was so fed up, I was legit skipping pages to get to more meaningful content.

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.

「ソフトウェアの複雑性を下げる」は、設計の主要な目標ですが、これについて簡潔に包括的に書かれた本です。 深い(浅い)モジュール/名前の横断性/コメント規約/情報隠蔽(漏洩)など、古い設計手法も新しい視点で書かれています。 Linterや計測ツールを作りたくなりました。

Excelente

Possibly my favourite tech book ever. Unlike other "clean code" books, it's not just a collection of advice, it unfolds a real theoretical framework that embodies the perks it touts in good design: simplicity, concision, consistency and pragmatism. It felt like the author somehow found just the right abstractions to describe what we pursue in good code. All served by spot on mental models (deep modules, information leakage), simple yet precise language and telling examples.

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.