Tools To Understand - Memory Training Journal

Memory Training Journals
1

I discovered mnemonics through Moonwalking with Einstein over ten years ago but I’ve just now started taking my training a bit more seriously so I figured I could include some logs here to help document and share my training progress.

I suppose I have two fundamental motivations:

  1. Its fun to create oddball visual images
  2. The techniques might help me learn topics that I don’t know much about already. Ultimately I think mnemonics aren’t nearly as useful for learning things that you already know a lot about because you have enough “hooks” to link the knowledge to AKA “understanding”. However if it’s a new topic you have to make new artificial hooks before the scaffolding of knowledge is in place. And since I’d like to learn a breadth of things mnemonics help those new things get into my head before the understanding is there.

My goals for training then are to train in traditional memory competition events for fun and for practice with quickly generating images. And also to train using mnemonic techniques in my daily life in order to learn subjects & topics that I don’t have a lot of experience with.

Currently I don’t have a developed number system and have only two competition journeys. I’m able to do about 20 minutes of random words training a day before the journeys I currently have get too cluttered. Today I did 17 words in 60 seconds, a new personal best. I have made progress on making images for my 3 digit number system and I would like to continue developing my numbers and cards systems however they aren’t nearly as important to me for my goals.

In terms of applied memory training, I frequently have to learn new complex code bases for my job and I’ve been experimenting with memorizing call graphs as a way to gain initial familiarity of the code I’m learning before diving into the code to get the complete understanding. So for example, memorizing graphs like this…

flowchart TD
    func1(use_core1) --> B(core_func)
    func2(use_core2) --> B(core_func)
    func3(use_core3) --> B(core_func)
    func4(use_core4) --> B(core_func)
    B --> C(helper)
    B --> D(processor)
    C --> D
    D --> P(poll)
    P --> D

would be helpful for when I am in the weeds of reading code to understand how this specific code fits into the larger picture and help grow my understanding of the code base.

One way to approach this is to place images for an “edge” (using a “from” image interacting with “to” image) at each locus. However I am having the difficulty of repeating multiple images repeatedly in the memory palace. In the above example I’d be placing the image for core__func over and over again for each edge pointing to it. And in reality there are generally much more than 4 edges pointing to or from the same node.

Another method which can work is to format the code more like a tree than a graph like this…

top_level_function()
  lock_thing()
  do_thing()
      do_part1()
      do_part2()
  unlock_thing()
  get_busy()
  continue()
  cleanup()
    free_item1()
    free_item2()

Then you use a link method/story method like this: Line Items that have children AND siblings will be linked with 3 images, the current item, the child, and the sibling. For example you’d have an image combining [do_thing, do_part1, unlock_thing]. Line items with just a sibling get linked just with their sibling like a basic list. For example you’d have an image for [get_busy, continue] You could place these images on a journey if you’d like, you’d trace all the way down depth first with that method. This method doesn’t work well to capture multiple callers to the same function though but it does capture the order of calls in a function though, which is nice. And you could generate the list in reverse instead of the tree of callouts you get the tree of callers, and do the same method. For C code these lists can be easily generated with the tool cflow and cflow -r

Anyways, this is a little about myself and the things I think about and work on in terms of memory and mnemonics. I hope to update this somewhat regularly with updates on my trainings and methods. See you around!

2 Likes
2

Competition

20 minutes - 3 rounds of words. I spent the first round with auto advance to work on my speed. Sadly my first round I always struggle, I thought I was going to recall 0 words but eneded with 3! My first attempts suck!

I narrowed my mistakes down to these categories

  1. swapping words – since I do two words per locus it’s sometimes possible to swap words order within the locus
  2. partial words – since I made a mnemonic for only some of the words I could only remember “multi-” and I couldn’t rememebr “multiple”, another example was that I had “absolute” instead of “absent” since I used a picture of “abs” to in the locus.
  3. Analogous words – I remembered “accident” instead of “mistake” since I didn’t use the phonetics of the word to make the image I used the meaning. This led to a mix up during recall.
  4. spelling mistakes – I typed “acquaintence” rather than “acquaintance”

I will have to focus on the techniques to solve these if I want to improve, as well as general speed.

Application

20 minutes working on a call tree for some code I’m reading, as mentioned in the last post. I was able to get 16 items memorized correctly, which is not many for 20 minutes. I think the link method is really slowing me down. I’m realizing that putting the links on locii would be really nice. I just don’t have many prepared locations nailed down. I want to spend some time soon brainstorming some locations I could use for this. Now to go apply this knowledge!

2 Likes
3

Some advice here, see if you can make the first word’s image act upon or cause some kind of effect that impacts the second word image. That way your format will always be 1 = cause, 2 = effect. That might help cut down on swapping.

Linking is tough when the list gets long. If you lose one link, everything after tends to get lost. As you said, the foundation of location based imagery is extremely powerful and worth spending time to develop first. It’s almost like trying to play jazz piano before learning the names of the notes and their position on the keyboard.

Spend the time to brainstorm 4 or 5 palaces with 10 locations each. Make the “end” point of each open ended so that you can expand these as you advance. Practice linking 2 images together at each loci. Make sure the features of the loci are able to interact with and trigger the recall of the first image. That way the mini-scenes will have a contextual setting in which to live and won’t be dependent on a singular link to recall them. If you are familiar with your journey, the order of your loci, those will keep your scenes ordered and you’ll be free of the consecutive link restrictions. You won’t need to link each scene to the next because the order of your loci will provide those links automatically.

1 Like
4

So the reason I’d still use links in the palace is because I’m trying to learn “trees” of words rather than lists. So rather than getting a simple list like this:

    flowchart
         A --> B
         B --> C
         C --> D
         D --> E
         E --> F
         F --> G(...)

and encoding like this:

    flowchart
         L1(Locus 1)--> L2
         A --> |interacts with| L1
         B --> |effected by| A
         C --> | interacts with| L2
         D --> |effected by| C
         E --> |interacts with| L3
         F --> |effected by| E
         G --> |interacts with| L4
         H --> |effected by| G
         L2(Locus 2) --> L3(Locus 3)
        L3 --> L4(Locus 4)

Instead, I’m trying to memorize a “tree” of information like this:

    flowchart
         A --> B
         B --> C
         C --> D
         D --> E
         E --> F

         C --> G
         G --> H
         H --> I
         I --> J
         J --> K
         K --> L
         L --> M

         G --> N
         N --> O
         O --> P

        H --> Q
        Q --> R
        R --> S

This kind of information is significantly harder for me than a simple list of words because you have to memorize the structure as well. I’m wondering if you have advice for memorizing this kind of information. Remembering words with this tree structure is significantly more beneficial to my career and real life than simple lists.

Maybe it’s smartest to force some physical location that you already know into the same structure as the information you want to learn? For example if C was at a fork in the road in your palace, then and image of D will be on the left and and Image of G on the right. I’ve never tried that. It’d be cool if there was a tool to generate a video game map based on these structures that way you could encode this information spatially.

Instead of encoding that information spatially I was attempting to use the link method to do that. So each loci gets at least the current word and the next one, or at most the current word and the two fork words. From there you could walk the whole tree sequentially placing the 2 or 3 image links on each locus. But it is slightly wasteful because, like you mentioned, you are double encoding the next words with both the palace and the link. I hope that makes sense.

I would love to know if you (or anyone) have other suggestions for encoding this type of tree data!

1 Like
5

I haven’t thought to much about branching variables but this would probably be my initial approach. Might be easiest to create your own set of loci, an imaginary palace, rather than trying to find or force a real location to it. Then you can also cater it’s “theme” to the info you’re working with

2 Likes
6

Actually, after writing all that out, I now think memorizing the tree could be done quite naturally just by using two lists. First you memorize all the items A through P in order using the typical 2 locus method that you might use in competition. You always go left till you reach the bottom and then go back up to the highest unfinished fork and go right once, then continue down left. You must follow this pattern. Then in a second palace, or at the end of the current one, you link the right direction forks. So in the above example you have a regular straight forward list A-P and then you memorize the list containing the right links from top to bottom (example from last post [CG] – [GN] – [HQ] ). Then during recall you get the first locii from the right links palace [CG] and draw all left arrows from A through F, then draw a right arrow from C to G. Then get the second locii from the right links palace [GN] and draw all left arrows from G to M and one right arrow from G to N. etc.

This seems to work okay, however if your tree mostly forking nodes you’d run into the same problem where youre basically doing the link method on top of a palace. In my use-case there tend to be more left arrows than right so this may be a fine method but that’s something to think about.

1 Like
7

Really interesting application. For data you’re looking to store long-term this is a cool approach as long as you can stick to a format where you can decode it with the correct branching.

Rather than messing with two overlapping palaces for and risking lots of interference and swapping issues, maybe there’s some kind of “marker image” that you can embed in the loci or scene(s) where branching occurs, similar to how some people place markers at every 5th or 10th loci so they can jump to a specific loci number?

Maybe like add a crossing guard or a traffic light or railroad switch… something to indicate there is an optional direction change? Then you might also need a distinct “left” or “right” indicator… but you may be able to use this as a starting point.

1 Like
8

You guys seem to be getting the gist of the logic here. There’s two ways that traversing the tree would work that you’ve outlined. The binary tree traversal of walking the tree involves levels of depth and could be implemented with the markers that @TheHumanTim mentioned. You would need a sign for right or left. Here’s an overview: Tree Traversal

The other way would be to have storage nodes/loci and decision nodes/loci where several paths take off. The decision node would be a rule and probably be converted from a story line. The branch of the tree that extended from the decision node would be an alternate story based on a unique datatype introduced at that decision point. Once the story is in place, you could add other alternate stories to a decision node but not change the location of the nodes.

I haven’t really seen a good use case for the tree structure and would like to if you have some data to share.

Doug

2 Likes
9

Sure I can provide my use case. For my day job I have to learn new code bases very frequently. Traditionally I have just started with reading functions that I felt were important and just read them straight through, maybe making notes along the way. However frequently I don’t get a lot of insight on the first few passes over these functions because I don’t have much context for how the source code interacts with itself. So I find myself reading a function call to something and not exactly knowing the implications of that function call, so not taking away too much.

So my application is to spend 20 minutes or so memorizing the output of cflow (which generates call trees for C code) before diving into reading the code. So for when I do come across a function I can better Understand the implications of the call without jumping around the code base. The idea is to use the memories based on arbitrary connections (aka mnemonics) to help me build memories based on meaningful connections (aka Understanding). I called my journal Tools To Understand because I feel these memory techniques can aide the painful process of understanding difficult things with zero background knowledge.

For me, mnemonics are useful only as method to speed up the early phase of learning when you don’t know enough to make meaningful connections OR for information which has very little meaning behind it to be found (eg. random lists).

2 Likes
10

Oooh I’m sure we’ll have some fun future discussions to try to change that perception! :wink:

1 Like
11

@alewis, so you want to build a tree of what functions call what functions? That would make a fairly complex structure. It wouldn’t be a binary tree and the branching could even be recursive. I don’t think I would try to do that. In understanding a code base (I taught programming for Java, JavaScript, C#) I found that first having good documentation was a godsend. But then who documents well?

Next, I had a sort of hierarchy of functions and needed to be identified to store them in my head. There’s the private utility, the one input / one output simple transform functions, the process management functions , and so on. That’s an understanding thing to figure out the purpose first. Then the utility functions are usually grouped by datatype they work on if I’m assuming it’s C++ or another OO language you work with.

The structure that seems more appropriate in my mind is more of the method of loci / memory palace / terrain peg for storage of kinds and categories of functions. My way of learning was to add the documentation myself actually and mnemonic aids never seems to work as well as understanding and doing a call trace with variable monitoring. The other thing that worked well was trying to build the code myself for a simple expected output and modifying the inputs to see if the output was still what I expected.

It just doesn’t seem like a tree structure works here and would become terribly complex over time. Good luck with this and I’ll try and help if I can.

Doug

1 Like
12

So, as far as I can tell, the “marker method” would need to point to the destination node. It’s not good enough to know just that a certain node has a fork, you must also know where it forks TO. This is why my original system used the link method on top of the locii. So that I could have multiple outward arrows (“edges” they’re called in computer science).

An alternative approach based on the marking method is to simply have one image per locii except on forking nodes where I’d need a second image representing the link to the right. So a link instead of a simple mark. You could also determine at the start if there tend to be more right edges or left edges and decide which direction to traverse the tree during encoding in order to minimize the nodes that have two images. I hope that makes sense? It’s basically the same as my original method but without the duplicate left traversal image which now instead uses solely the journey to be derived. That makes a lot of sense, thanks.

So for example encoding as a straightforward list using one of the Tree Traversal methods ( for example Pre-order Traversal like I described earlier), and only when you reach forking nodes do you encode a second image. This seems ideal for Unbalanced Trees.

For perfectly balanced binary trees I like the approach that @joereddington had in his book. Though I’m not too sure how frequently I’ll get the chance to order the information I’m interested in learning. Also I’m not too sure I loved any of the methods for encoding unbalanced trees. I’ll have to give it another read later this week. I also wish he shared some thoughts on encoding graphs as well.

1 Like
13

Yes the cflow utility that I linked to above handles recursion just fine. I do want to keep pulling on this thread though because I have found even my limited progress down this avenue has helped me. Ideally, you are correct, the call tree is a limited view of how the code can run, but the point isn’t to be perfect but to land a beachhead of knowledge to then build my temple of understanding on top of. Memorizing a complete CFG and AST would provide the deepest and most accurate representation of the code but in the long run would be nothing but forgotten anyways.

Ultimately my goal isn’t to have some perfect representation of an computer program in my head. The goal is to memorize the relationships of the code I’m going to review for next few hours so that I have greater context of how those functions relate to one another and thus can draw deeper insights during the code review sessions.

That being said I am curious how one could encode an arbitrary graph. These are the kind of events that I personally would love to see in memory competitions!

Thanks everyone for your input!

2 Likes
14

An analogy is like reading and thinking about the table of contents before reading the textbook. Or reading the introductory sections of a chapter. I think having a lot of exposure to the context and organization of information can be very helpful to help piece together the new information. That’s what I’m attempting to do with the call tree stuff :slight_smile:

2 Likes
15

Competition

I only did two rounds of words with my best being 16 in 60 seconds. I decided to start an anki deck with “type” fields and with the goal of always adding words that I spell wrong into this deck. For example I misspelled “repretoire” :disappointed:.

Emphasizing the first word interacting with the locii and the second interacting with the first was very helpful. For example, I encoded 16 words and “grabbed” 4 for that round and only had 4 mistakes. All the mistakes were “partial recall” type where I memorized some core feature of the word but I got the actual word wrong. For example I recalled “reproduce” instead of “reproduction”, or “invert” instead of “divert”. I think I should maybe encode more than one syllable, like for “divert” I envisioned a vert ramp, but I could have put some dice (“die”) going up and down the vert ramp to help recall “divert.” Or for “reproduction” maybe envisioned shins reproducing to make “reproduce-shin”.

Other than that, I just need to go faster!

Application

I memorized another small snippet of a call tree on the code I’m looking at today. I’m actually quite happy with my newest method it seems quite natural to me. I take the tree output that looks like this:

A
  B
  C
  D
    E
    F
  G
H
I
J
  K

And I first memorize A-K in order, disregarding the structure, putting two images per locus, just like competition words event. Then in a second palace I place images for [AH], [DG] and [J]. Then, during recall, I first walk through the palace with all the words just down the list. Then I go through the second palace and see [AH] so everything between A and H get’s indented, then I see [DG] so everything between D and G gets indented. and I finally see J so everything below J gets indented. And with this method I can perfectly recreate the words and the structure.

There are still a few challenges

  • The words for this application are really difficult since they are all technical function names. There are zero regular nouns like “snorkel”, or “apple.” They are all abstract things, so you really have to stretch your imagination to make something you can visualize. It’s probably good practice at least.
  • Occasionally the structure has repeat words which is usually fine but gets a little complicated when your structure palace has a link between the duplicate. So for example if your word list is A B C D E F D G and your structure list shows AD you don’t know if you should indent BC or BCDEF. Though so far it’s been fine to just figure that out with context clues, so not a huge problem yet.
  • Still don’t have any good palace lists to use for memory so I am kind of improvising the palace as well as the images during memorization

All of these problems combined I think contribute to why I’m only able to memorize 14 items in the unbalanced tree in about ~15 minutes :cry:. But I think all these problems are addressable.

2 Likes
16

Competition

The thing about memory sports and improving is: go far beyond your limits and then decrease mistakes, that’s the secret.
– Johannes Mallow

I’ve noticed that I’m really trying just to get nearly the exact score that I need. For example, right now I’m at “level 6” in words for the memory league trainer. For this level, you need to get 18/26 words right to get to the next level and I was only trying to get perfect 18 words. From now on, I’m going to shoot for all the words presented on that level and then put my efforts onto fixing mistakes.

Another piece of advice is to put myself involved in the story and to use the feeling that words can provoke as well.

Training result:

  • 1st attempt – 14/26
    • 3 locii gaps, 2 half gaps, 2 partial recalls, 1 analogus recall, 1 grab mistake
  • 2nd attempt – 15/26
    • too slow, missed last 6 words, 1 locii gap, 1 spelling mistake, 2 partial recalls

Today I also did 20 minutes brainstorming new locations

1 Like