Trying a "lazy loading" style of adding cards

[badlydrawnrob]

This needs a proper article, that's a bit clearer so you'll have to use your imagination for now![^1]

Every time you learn a new language, it adds "cognitive overhead" and can, potentially, muddy the waters of your knowledge pool[^2]. Learning more than one thing at a time can also lead to the context switching problem.

The bigger and more interconnected the code sample, the harder it is to distill down in a card without losing context. For larger programs, consider splitting out the key learning material into two files:

1. An isolated code file, with the core learning point and notes.
2. The code in it's larger context as a full working program.

As well as Anki cards I often have full notes within a chapter_01 folder with the working program. For chapter_02, I'll copy these files over (in a new folder) and remove the notes. This forces me to figure out the code without any notes, but I can always refer to the earlier chapter. Writing in your own words also forces you to think about things carefully!

• [x] An example of notes taken and list of potential cards (cards not created yet)
• [x] A revised list with grouped, numbered notes (cards to be created)
• [x] A further example of grouping a longer, more complicated set of numbered notes (and how it was grouped).[^3]
• [x] An example file that's handy for seeing some learning points at-a-glance (or, just use the Elm Guide)

Understanding comes first!

Problem: Working in this way is slower as you can't zip through the book when you're carefully marking up your code with notes. By the end of the chapter, however, you'll have a (hopefully) nicely laid out file with helpful comments, and a set of learning points as a list to begin creating your cards in Anki (which will hopefully be far fewer and more focused).

Elm-in-action does a good job of summarising the learning points at the end of a chapter, but I've found once learned, skimming the book for reference is slower than having a set of notes with examples in-place.[^4]

I often forget things, and scanning a programming book for information isn't always the easiest thing. So having an abbreviated set of notes (whether in Anki cards, program files, or a short-form notebook) really helps rejig my memory.

I'm trying a method where understanding comes first and the aim is not to memorise code only. It isn't an exercise in cramming with an Anki deck. This comes with a caveat that I'm already further down the learning path and not a beginner (in which there's a vast amount of syntax to remember).

I'm also taking care not to rush things and being ok with spending a whole learning session with, for instance, only understanding a single function (and understanding it well).

• [x] Use comments to add notes or document code
• [x] Add snapshots of diagrams from the book (not added to source control)
• [x] Something new? Something difficult?
  • [x] Write it down! (with no intention of adding cards yet)
• [x] Revise the list (or snapshots)
  • [x] How well do you remember?
• [ ] Then (and only then) decide which cards to create
  • [ ] Add images and code samples where appropriate

I'm also not interested in memorising every little detail in the Elm in Action book, but broad strokes which could be linked back to sections of the book, or further articles at a later date. Highlighting some sections of text in the book can be useful too. I don't care about the Javascript comparisons There's a lot of stuff about comparison with Javascript so can safely leave that out (unless it's similar concepts).

Where there's code that I've seen before:

You can safely ignore x, y, z

For instance, while HTML is not new to me, the Html module is. It's reasonably simple lists (an attribute list and a children list). Using functions within the HTML will need some examples.

1. Html and CSS I already know!
2. Lispy language a so-so grasp of; rely on memory for similar concepts.
3. New concepts will need to be written down somewhere.

Questions:

• You're highlighting sections in the ebook/pdf also. How useful were these?
  • I'm not sure how often I'll revisit the highlights in the ebook, but I think I've got the jist of the thinking (if not all the terminology) down in files or Anki cards.
• Is a syntax file, or a notes section a better way to scan for information than adding Anki cards?
  • In some cases, most definitely — for simple syntax and stuff to view at-a-glance.
  • I've got one version of the working file that's clean, with almost no notes.
  • I have another one with plenty of notes to fall back on if I don't understand what I see.
  • Use the tree to save files as a link for a specific commit.
• Which bits am I getting stuck on, or finding hard to remember?
  • You have your revised list (see above) for cards to add now,
  • You can revisit the code later to see what you remember. Do you really need a new card?
• Can I interleave different bits? (where some are question/answers; within those there's some contextual rejigging of the easier bits)
  • Interleaving similar themes with programming languages you've learned before,
  • Some things you'll remember through osmosis in future chapters, building things, or simply looking at a card with contextual code!

Also see:

• [x] #72

[^1]: Also see these ramshackle issues to tidy up and make sense of as "evergreen" knowledge: lazy learning and other methods, as easy as ... finger painting for adults — the general gist is "what are the better ways to learn" and I need to distill some teaching and learning theory down to bitesize chunks. It takes quite a long time to do, however, so it might be some time.

[^2]: In terms of getting muddled up with this or that language; unless you're a polyglot and very good with languages, it's quite the thing to learn a new language, or framework. As you get older, you have to be extra careful with your time, so it becomes clear that weighing up the pros and cons of learning something new is essential. Lisp and Elm are far enough apart to not make mistakes, but Typescript, Javascript, React, Vue, etc, are easy for one to bleed into the other.

[^3]: This list is quite messy and there'll be duplicate points or stuff that can be mushed together. The chapter in the book wasn't overly long, but it had a lot of learning points for Types and other things like Maybe. Elm lang, and functional programming in general aren't what I'd call beginner reading material. Perhaps object-oriented or type-less programming languages like Python or HTDP's teachpacks are easier to wrap your head around (and therefore creating cards is easier). The main point is, as your learning becomes deeper or more involved and the programs become bigger and more intertwined, creating good Anki decks becomes a bit harder. Can some examples become part of an example program or small note book? Which learning points are a poor fit for card creation?

[^4]: Even these notes aren't foolproof and depend on how well you've written, or understood, the chapter. That's where documentation comes in to play as a shorthand for more verbose learning notes. Ideally you'd create your own documentation with memorable examples — but who has time for that? The downsides of documentation is it can be overly academic or assumes understanding of terminology. If you're anything like me, terminology is difficult to remember — i.e [the difference between an operand and an operator](https://www.lenovo.com/us/en/glossary/operand/#:~:text=What is the difference between operand and operator?). I know what each are in practice, but my memory of terminology can be muddy! (I just say variables and arguments.)