Found in 22 comments on Hacker News
"Design Patterns: Elements of Reusable Object-Oriented Software" (1994) is still going strong, in my opinion, and I don't think that will change in the coming 5-10 years.


danielbarla · 2022-01-10 · Original thread
Object oriented programming and design patterns in particular get a bad rap these days, however, the original Design Patterns book [1] has a case study chapter about designing a WYSIWYG document editor. Also, one of the authors, Erich Gamma, joined Microsoft in 2011, and works on the Monaco suite of components that VS Code is built on top of. So, while I am sure there's a fair bit of difference in the years since they wrote that book, as well as the needs of implementation in JS, I'd say it's a fairly good deep dive into some of the topics from one of the actual architects behind it.

Fair warning though, it's a fairly hard book to read. For a lighter, more fun intro to design patterns in particular, I always recommend Game Programming Patterns [2]



fsloth · 2020-10-28 · Original thread
This codebase won an Oscar:

That said, IMHO, there is no "clean" C++ code. There are C++ codebases that use different styles, and their "quality" more or less is context sensitive.

Personally I felt the best tutorial to C++ were actually two other programming languages - Scheme and F#.

Scheme drove in the concept that it's totally fine to model things based on the shape of the data and that you don't need to create type based abstractions around every thing.

F# then demonstrated how a language with type system is supposed to work.

The problem with C++ is that the language is so verbose that unless you have an abbreviated model in your head how a type based language can be used to solve problems in best way, you will get lost in trivial C++ minutiae.

So, personally, I generally think "Am I solving a Scheme like problem or Standard ML like problem" and then try to apply C++ as simply as possible.

Several academics have created a career of how to patch C++/Java/C# with concepts that make them less fragile in a collaborative context:

In my opinion design patterns are not a fundamental concept, but rather provide common syntax for collaboration purposes for various patterns that are parts of language and more or less invisible in e.g. Scheme or F#. But if one is diving into C++ it's probably convenient to be familiar with these concepts.

gitgud · 2020-04-14 · Original thread
> Ideally I'd like to find a more formalized treatment of "abstracting" in the vein of the GoF's Design Patterns.

Well [1] that book you're referring to, has changed my perspective on abstractions and how to communicate them to other people. There's probably no "Holy Grail" of abstraction guides better than that IMHO.

Designing and implementing useful and maintainable abstractions comes from experience in both consuming and designing abstractions for API's. Having empathy for both the consumers and future developer's of the API gives you a good perspective on how to structure the abstraction.

The best abstractions are from people who have used bad abstractions, and are usually incrementally developed over time...


sebscholl · 2019-08-14 · Original thread
I'm ready this book right now, and it's great.
rcavezza · 2019-03-18 · Original thread
Refactoring by Martin Fowler is a great one

Design Patterns is also very well known

CodeSheikh · 2019-01-17 · Original thread
Nice list. Appreciate it. But I see there are a few amazing software books missing from the list such as:

- Clean Code (by "Uncle Bob")) []

- Design Patterns (by "Gang of 4") []

- Introduction to Algorithms (by "CLRS") []

PaulKeeble · 2017-02-16 · Original thread
The classical Design Patterns book has a first chapter which takes you through the design of a text editor using the patterns provided in the book. If what you do is read the chapter and then the patterns referenced as you go and build the text editor based on their design you get exactly the sort of thing you are looking for. Its a different way of doing it than the entire book but arguably just in a different format for what is otherwise a reference book.

jasode · 2017-02-08 · Original thread
>, the good old Design Patterns book, responsible for more atrocious over-abstracted,

This is a misunderstanding of the DP book. It would be similar to saying that the existence of is responsible for terrible scripts of tv shows and movies. Or, the existence of the Oxford English Dictionary is responsible for bad novels and useless documentation.

The DP book is a catalog (to gain awareness) and not a checklist (that you must do). It's a collection of observations about software structures out in the wild. It's not about prescription.

Even without the phrase "design patterns", it's easy to surmise that programmers out there are independently and unknowingly re-inventing the same higher-level structures (similar to tv tropes) but without giving them formal names. The DP book gives them formal names and hence, an attempt at shared vocabulary.

One can go to the page for Design Patterns and click "Look inside" for the "First Pages" and see that the authors wanted to present a catalog:

peller · 2016-12-11 · Original thread
There's always the classics:

EDIT: And it appears the website is a direct rip-off of these books.

jrochkind1 · 2015-06-22 · Original thread
Design Patterns: Elements of Reusable Object-Oriented Software

Practical Object-Oriented Design in Ruby by Sandi Metz.

chton · 2014-07-07 · Original thread
Dive into design patterns. Get yourself a good book listing them. The bible of all developers is the Gang Of Four (, but there are plenty good ones out there that aren't as dry and academic.

Design patterns are the greatest tool there is for learning software design. If you know them, you can apply them, but much more importantly they show you how you can apply the basic principles of OO development to various problems. By learning them, you're learning the thought process of how they came to be, and you'll be able to apply those thought processes to your own problems. Consider it like learning algebra by doing exercises. You can read theory all you like, but unless you apply it it just won't click.

optymizer · 2014-07-07 · Original thread
Just in case, here's the 'Gang of Four' book on design patterns:
We've known this since at least 1994, when the GoF book [1] famously said:

"Favor object composition over class inheritance"


klaaspieter · 2014-07-03 · Original thread
Yes. I believe such a book exists (or should at least) for every language as well.

Effective Java —

POODR (Ruby) —

Javascript the good parts —

There is of course also the gang of 4 language agnostic classic on design patterns

mandor · 2014-04-28 · Original thread
- Design Patterns: Elements of Reusable Object-Oriented Software

- Effective C++:

robomartin · 2012-11-27 · Original thread
OK, if you don't have any real experience in low-level embedded coding (relevant to device drivers), RTOS or OS design in general, file systems, data structures, algorithms, interfaces, etc. And, if you have "hobby level" experience with Assembler, C and C++. And, if your intent is to write a desktop OS, from the ground up, without making use of existing technologies, drivers, file systems, memory management, POSIX, etc. Here's a list of books that could be considered required reading before you can really start to write specifications and code. Pick twenty of these and that might be a good start.

In no particular order:






















































54- ...well, I'll stop here.

Of course, the equivalent knowledge can be obtained by trial-and-error, which would take longer and might result in costly errors and imperfect design. The greater danger here is that a sole developer, without the feedback and interaction of even a small group of capable and experienced programmers could simply burn a lot of time repeating the mistakes made by those who have already trenched that territory.

If the goal is to write a small RTOS on a small but nicely-featured microcontroller, then the C books and the uC/OS book might be a good shove in the right direction. Things start getting complicated if you need to write such things as a full USB stack, PCIe subsystem, graphics drivers, etc.

dbingham · 2010-10-07 · Original thread
The only way to learn how to program is to just do it. Pick a language. Start with small programs. Learn the features and syntax of the language. When you feel you know the language well enough to write a program that uses most of its features, then pick an open source program and learn its code. Make some modifications to it. When you feel you're pretty comfortable in one language, pick a new language.

Rinse repeat. You'll find that once you have one language down, the process will go much faster with the second. The features and syntax of most languages are pretty similar.

You can pick any language you like to start with, but personally I'd recommend starting with a hard typed compiled language rather than a dynamic language. Dynamic languages are easy to learn, but its easy to be a lazy and bad programmer in them. They let you get away with too much. Hard typed compiled languages are a) much better at catching your errors and b) much harder to be a lazy programmer in. They don't let you get away with things nearly as much.

I'd recommend Java, seems to be the language a lot of people start with. It will also give you a good founding in open source programming. I started with C/C++ and I'm glad I did. But that was more of a challenge - had to learn pointers and memory management in my first language. And after that I took a little while to learn the open source mindset, since I'd started in a procedural language.

Once you have a good grasp of an object oriented language like Java (or Python) and what object oriented programming means, then I'd recommend reading the Gang of Four book on Design Patterns ( and Martin Fowler's book on Refactoring ( Those will give you a pretty good basis in software design and maintenance.

In terms of recommended reading for learning a language, the O'Reilly books are nearly always good in my experience. Here's one for Java (Learning Java: and here's one for Python (Learning Python:

lukesandberg · 2010-08-06 · Original thread
I know no one like to read a text book, but good option would be picking up the Gang of Four design patterns book. I recently read most of it (preparing for a final exam yay!) and the really nice thing about this book is the examples. Each pattern has a description, a list of pros and cons, a discussion of a piece of real software that used (or often pioneered) this pattern and then finally an example of C++ that uses it.

Honestly, the discussion of pros/cons and then the use in industry sections make this book a very good read. It won't be quite as entertaining as lippert's blog, but then again it is a Textbook

Fresh book recommendations delivered straight to your inbox every Thursday.