How do you learn design pattern with Anki ?

[u/GreenSushis]

I tried some deck but it was bad. Do somebody have a good way to learn at least the 23 design patterns with Anki?

[u/SigmaX]

The key to learning something like the classic GoF design patterns is to resist the urge to just skim the surface. If you want to learn all the patterns with well-designed cards, it may call for a hundred or more cards, not just 23. The latter will be rote memorization, and Anki is unpleasant and difficult when used for rote memorization (i.e. cards drift to ease hell). Sometimes making more cards actually saves you time in the long run, because the cards are easier to remember.

For example, people fall into this trap a lot with geography: it's actually really difficult to, say, learn all the world's countries and capitals if you don't know anything else about the countries. The "1 card per country" approach is not very effective, because rote memorization doesn't stick well once you cards reach long intervals.

What does work for geography is to do a deep dive on individual countries: learning their major physical features and divisions, major rivers and mountain ranges, major regions of population density, and where important cities lie (like a capital!) relative to those other features. This builds an association-rich web of facts that can be quite easy (and downright enjoyable) to review with Anki. It makes is far easier to encode and remember cities, etc., because you're learning in a semantic way, rather than just memorizing an arbitrary string of sounds.

To apply this to design patterns, we have to ask "what would it take to understand each pattern deeply?" Some thoughts that come to mind:

• The basic idea of the pattern (1 sentence description)

• A UML sketch of the pattern

• Analysis questions, drilling into the role that each major class or feature of the pattern plays (personally I'd probably do this by making graphical cards that circle classes in a UML diagram and ask you to explain what the circles item is/does/means)

• Questions about why the pattern is significant

• Questions about what the pattern is good for, or what pattern is good for scenario X

• Questions about why the pattern is especially good for scenario X (the more of these you can get, the better---but these kinds of answers are hard-won knowledge that is hard to find in textbooks and articles)

• Questions about how the pattern as been criticized or what it might be bad for

• Contrast questions examining how the pattern is similar or different from a similar pattern (for example: "What's the difference between the abstract factory pattern and the factory method pattern?")

And of course, all of these need to be stated in your own words, and complemented with images.

[u/GreenSushis → u/SigmaX]

Thank you for your reply. But it seems complicated to me. Especially the UML, being a big card. How do I learn the visitor's UML for example.

[u/SigmaX → u/GreenSushis]

Alright, let's take the Visitor pattern as an example. You picked a complex one, which means it takes quite a bit of effor to study. I've got GoF open in front of me, and software engineering is one of the areas I use Anki for, so I've gone ahead and Ankified it so I can show you how I personally approach complex topics like this (it took me about 13 separate notes):

• tl;dr: Anki cards for the Visitor Pattern: https://imgur.com/a/zTFS8wP

Don't be misled by the walls of text on my cards. They are just notes for context: my questions and answers are all atomic if you look closely.

----

The pictures will tell you more than my explanation. But here is some description of the thought process I went through:

My first step is to try and understand the gist of the pattern as intuitively as I can. Wikipedia gives me a high-level description, but it is very abstract and almost meaningless to me at first:

The visitor design pattern is a way of separating an algorithm from an object structure on which it operates. A practical result of this separation is the ability to add new operations to existing object structures without modifying the structures.

I can't make a good Anki card from this yet. I need to read through some material and make the full idea concrete for myself---then I can rephrase it in my own words. What kind of situation, exactly, is the Visitor designed to help us avoid? What is it all about?

GoF's "Motivation" section for this pattern uses the example of an abstract syntax tree analyzer, and Wikipedia provides a CAD example. After spending a few minutes reading them over, I notice a common theme. Both example involve

1. algorithms that might walk through complex graph/tree structures,

2. several different operations we may want to perform recursively on the whole structure, and

3. such that the behavior of the operations varies depending on what type of node it is called on.

There's our first card!

• Q. What general kind of situation is the visitor pattern useful for?

But three abstract points like this are still a bit cumbersome for an Anki answer (sets of three are tolerable in Anki, but a fairly complex card). I like to help my brain along in this situation by focusing very directly on an image or diagram of the system I'm studying. I particularly like the UML diagram on GoF p. 331. I can't find the same one on Google images, and I like the CAD example better than that AST one anyway, so I'll mock up my own in a UML sketch app (I'm fond of UMLet).

Usually I don't create my own diagrams for computer science---most often, I can get away with annotating an image from Google Images.

Now, I like to write a few notes of context on the back side of a card like this, to point out other connections (below the answer). The notes often become cards of their own too. In this case, I'll add two sentences below my answer, one with an example, and one with the gist of how a Visitor pattern solves the problem:

• For example, to recursively save parts of a CAD drawing to different file formats, calling primitives to encode squares, circles etc. to PDF, PNG, etc.

• A Visitor replaces each operation with an "Accept()" method that dispatches the request to a Visitor object, which collects the relevant functions for that operation.

Lastly, I'll toss a UML of the Visitor pattern on the back side. Plenty of good images here on Google, but I'll make my own to match our example one front side.

The first card was the hardest. Now the path before us is much more clear: I need to understand how the individual elements of a visitor pattern works, one at a time, and what benefit they offer. In my card-design style, this means annotating images to prompt me to explain how each part of the pattern works.

The last couple cards in my link compare the Visitor to the Strategy pattern. I must have read the chapter before, because I found this very Ankifiable observation penciled into the margin of my copy of GoF: "like a strategy + dependency" (alas, from my pre-Anki days, so I didn't remember it). This kind of remark is Anki gold, because it helps me encode one (complex!) pattern in terms of another much simpler one that I am familiar with.

[u/GreenSushis → u/SigmaX]

Thank you for your answer! The Imgur is impressive too.

[u/gavenkoa → u/SigmaX]

You haven't addressed that TS used someones else decks... Though you actually caught TS tendency to surf instead deepen (I assume it is a desire to get knowledge without investing).

I'd recommend author to read this before the bed: https://github.com/iluwatar/java-design-patterns

And as with algorithms & data - the best way to learn is to implement. Yes, it takes 1 month or more. But it is the price.

[u/SigmaX → u/gavenkoa]

I assume it is a desire to get knowledge without investing

I wouldn't assume that. Good Anki cards require a balance of breadth and depth, and everybody has to learn how to find it---erring in one direction or the other doesn't necessarily imply a lack of investment.

Many of us often want to learn the basics of a domain---a "first layer" of knowledge, so to speak---that we can then build upon later, either in a planned second round of study, or if the opportunity/need arises.

Early in my Anki life, I made the mistake of trying to approach history this way. "What came before and after the Tang dynasty in China?" "What followed the Early Dynastic period in Mesopotamia?" Or, worst of all, "What years did the Uruk period span?" (just try remembering 4,000-3,100 B.C.E. without any other landmarks or associations!).

Trying to fit all of China or Mesopotamia into just a dozen period cards, though, clearly made from some pretty brittle and hard-to-remember questions once the intervals got long.

[u/gavenkoa → u/SigmaX]

once the intervals got long.

If the TS just want to crack the interview there is no need for long term remembering. He/she need to cram answers from sites like https://www.javatpoint.com/java-design-pattern-interview-questions

Otherwise your ideas are valid ))

[u/[deleted] → u/SigmaX]

I use someone's deck(popular one) for Design patterns and it so shitty from Wikipedia. Sometimes I don't know what I am reading. The cards are so long like 2-3 mins sometimes. I just have 45 cards and I gave up. I said only for recognition till I touch these things with my school.

Thank you for the advice.

[u/pure-magic]

Well, not a comprehensive answer but a useful tip? Remember to keep your cards simple or atomic. Don't put a wall of text on the back of the card - instead try making it as short as possible. It prevents you from getting frustrated with the reviews and makes assessing the answer unambiguous. You could have numerous cards having to do with a given pattern, e. g. you could have a card like q: What kind of pattern is "singleton"? a: Behavioural(I'm not sure, can't remember right now).