Hacker News Reader

Comment by rmbyrro | Hacker News Reader

Some of these patterns have proved to be really powerful in real-world projects.

One challenge is having them fresh on my mind and being able to spot when it makes sense to apply them.

Have been thinking about using flashcards and spaced repetition to achieve better retention and ability to apply in practice.

Anyone has experience with this?

View on HN

I made the experience that they are hard to learn and understand out of context, so practicing on flashcards does not make much sense for me. What I did is programming some mini projects in which one or two patterns are used: Pub-sub is nice in anything UI related, commands+state is great for a simple undo/redo-manager etc.

Agreed. I'd use flashcards just to retain a fresh memory of what I've already learned with proper context and practice.

Insanely powerful and underutilized technique: write a list of techniques you can apply (in this case, patterns). Just write the names, you want this to be dense. When you have a choice to make, look at the list. It doesn’t take long to scan 12 names.

That makes sense. Just thought about having the list as a colletion of flashcards and using a software like Anki to automate the revisions.

I know and have used these patterns. Some I use frequently, like Observer. The less frequent ones just fade in memory, and I get myself constantly in need to read about many again to refresh and identify which to use in a particular case.

And I suspect I'm missing many potential uses, due to not having them very fresh in mind all the time.

That's where I presume SRS can help...

I’m very familiar with SRS and I think you don’t need it here.

I get what you’re going for. You learn the patterns, but then you don’t recognize the opportunity to use them. You think you have to keep the pattern in your recent memory so you’ll recognize the opportunity to use it.

Here’s the trick: you don’t have to recognize the opportunity to use a pattern. You just have to recognize the opportunity to use a pattern. Instead of thinking “ah yes, Builder pattern would go here” you can just think “maybe there’s a pattern that would be useful here. I’ll scan my list of patterns taped to my monitor. Builder would maybe work? I’ll double check what that means”.

This is 1. Way easier 2. Consistent across many patterns. Instead of learning to recognize pattern A, B, C and so on, you just get a vague feeling of “pattern”.

This (obviously) doesn’t just apply to patterns. Super useful for web frameworks. List the 10 places you could put behavior (model, field, view, etc) and choose consciously. Same for data structures in algorithms and even all sorts of non-programming stuff.

Use good libraries and pay attention to what makes them appealing. Large programs should usually be structured as a collection of libraries. When you are designing an API for your own libraries, think back to how other libraries solved similar problems at the API level. Many (most?) worthwhile design patterns can then be derived from scratch as a way to achieve a particular API structure.

Maybe work from the other direction? Work through each pattern and think about where they might work in your existing codebases and then try implementing them just for the sake of hands-on experience.

My experience is that worked, traditional textbook-style exercises are the best way to learn and internalize this kind of knowledge. A combination of shorter exercises with longer open-ended tasks is good. Basically more or less what you'd get on a homework problem set in a university course.

Maybe the fact that this kind of work ends up being "spaced repetition" in some sense is part of why it's helpful.

As others wrote, in depth practice is a sensible choice. Once it's done, I believe spaced repetition is a nice insurance against memory fading and can be as simple as a few big cards listing the concepts learned even if that's really not what spaced repetition proponent would suggest.

Reply on news.ycombinator.com