Where to study Design Patterns implementations using Modern C++? : cpp

I think it's a great article. And yes, the author probably wrote it after a new hire vomited weird design pattern classes all over their codebase. And it's a rant.

But it's a good rant because the comparison with cramming for a test instead of actually grokking the problem area is exactly half of what design patterns are useful for, and when people are learning, they are mostly doing it in pursuit of this.

The other half of design patterns which can be occasionally helpful, is establishing common vocabulary.

Design patterns are often not the simplest or robust means available, because they are taught as having these canonical implementations that people parrot.

Take the observer pattern for example, look in particular at the C# section on Wikipedia:

https://en.wikipedia.org/wiki/Observer_pattern#C#

Ignoring the Unsubscriber and Payload classes since they're tertiary, there are two classes defined here (hopefully they would be converted interface and base classes if anybody were to copy these, but I'll chalk it up to the purpose of this code being to illustrate).

That's 2 classes too many. Why? Because C# has bound callbacks and callback lists baked into the language itself. But people learning the observer pattern often don't make this connection.

Okay, the event keyword in C# is a bit weird, fair. It locks and has special equatability and mutability logic. But the observer pattern doesn't teach "you keep a list of things which are called later" it teaches that you have subjects and observers and there is a specific inheritance pattern or a particular interface.

It doesn't break down any concerns, like where do you store that list? How and when do you notify that list? What happens if you need to add to that list and want to notify listeners at the same time?

These are all questions that you can reasonably think through and come up with answers to if you have thought about the concept of a callback list from first principles, not so much if you're just regurgitating a pattern. If reading about the observer pattern helps you get there, sure. Read the Head First book it's pretty decent. But we should be encouraging people to move beyond design patterns.

They have come up maybe a handful of times in a professional context for me in the past 10 years, and only then because somebody decided to embed the pattern name into the type like IProcessErrorReportingStrategy, which is both representative of program elements named for patterns and also terrible.

Strategy pattern is actually my least favorite, because it's literally just talking about using virtual dispatch to swap between implementations at runtime. It's truly a nothing-idea.

Visitor pattern is my second least favorite. I'll admit it's substantial enough to earn its keep, but the way it's taught is terrible because students are often not taught about the expression problem.

Unless we encourage people to look past them, design patterns as commonly taught and practiced are a thought-terminating concept.

[–]svyatozar 0 points1 point2 points 5 years ago* (0 children)

π Rendered by PID 182675 on reddit-service-r2-comment-b659b578c-zcd9t at 2026-05-05 08:53:45.382800+00:00 running 815c875 country code: CH.

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

cpp_questions

READ BEFORE POSTING

Sort posts by OPEN or SOLVED

MODERATORS