Beau's Journal: Cyber Mnemonics. Syntax, Structure, and stuff

[beau2am]

Beau’s journal:

Python, Networking, Binary, Math, Bash and Other Jargon

TLDR;

It’s long.

I’m well into the swing of things.

This journal logs/documents aspects of my Sisyphean effort to memorize a cybernetic mountain of knowledge.

I have a little pen and paper composition book I journal in, but nobody else reads that or asks questions about it, so I miss out on all the devious joy encountered from conversing with others and playing with ideas.

Documenting myself and my processes is nice, in theory.

And I much prefer conversations (where folks use their voices).

That’s fun.

Where I’m at / Where am I going?

I’m memorizing Bento box style.

A big thing.
A medium thing.
And a small thing.

Right now the big thing is CCNA (network engineering).

The big thing was Python programming.
My first programming language (that wasn’t html in the early 2000s).
And a language that, prior to 6 months ago, I had never touched.

However, I’ve memorized large portions of the Python documentation, as well as concepts on Object Oriented Programming among other things.

I started memorizing the Python documentation on about December 12th, 2023, I think.

Beau's guardian angel, here. I hid this part because he just sounds like he's bragging.

By December 28th, I passed all modules for the Certified Associate in Python Programming (PCAP) practice exam. On the first try.

Out of anyone who might be impressed, I was the first.
Surprised, impressed, and giddy. Me Me Me.

If you’re not impressed that’s fine. I still was.

Since I’m still expanding on the information, I’m holding off on taking the official PCAP until I feel ready to knock out the Cisco Certified Network Associate (CCNA) exam.

Then I’ll take both. A nice one-two combo.

But I still won’t be close to my ultimate goal. I don’t mind. I’m patient.

You Are Here (aka, Where is Beau)

Points to the dot on the map that looks like me

That’s me.

I’ll give a brief overview of topics I’ve covered, and what’s in the near future.

Note

In retrospect this was not brief

Syntax. I’ll memorize Syntax verbatim.
Concepts, not usually.
Examples, rarely.

Voice drops to gravel
— I make my own examples.

Here’s the sections where I’ve memorized most of the concepts, functions, methods, arguments and parameters (I’m estimating over 80%, I don’t think it’s wishful, but I am wishful. In the words of Bill Murray from Caddy Shack, “So I got that going for me.”).

The Python Standard Library Reference

Index of Memorized Sections as of 2024, Feb 6th.

• Built-in Functions
• Built-in Constants
  • Constants added by the site module
• Built-in Types
  • Truth Value Testing
  • Boolean Operations — and, or, not
  • Comparisons
  • Numeric Types — int, float, complex
  • Boolean Type - bool
  • Iterator Types
  • Sequence Types — list, tuple, range
  • Text Sequence Type — str
  • Binary Sequence Types — bytes, bytearray, memoryview
  • Set Types — set, frozenset
  • Mapping Types — dict
  • Context Manager Types
  • Type Annotation Types — Generic Alias, Union
  • Other Built-in Types
  • Special Attributes
  • Integer string conversion length limitation
• Built-in Exceptions
  • Exception context
  • Inheriting from built-in exceptions
  • Base classes
  • Concrete exceptions
  • Warnings
  • Exception groups
  • Exception hierarchy

---

Beyond the standard built in features of Python, I’ve memorized all section titles for modules, and the names of all modules up until Concurrent Execution modules (after that it’s dicey).

If you see the module listed below it, I’ve got something from that module memorized in a palace/memory journey.

Some modules, like the math module and the random module, I have all the functions and arguments/parameters memorized.

Others, like the Email module, only top level concepts at this point.

And others (like Kivy, Flask and Requests), aren’t listed, because they’re not built-in. But I have some aspects of those memorized as well, and continually work to expand them.

Memorized Module Index

(ie, I at least have the title memorized)

If module is listed, some aspects of that module exist in a palace/journey.

• Text Processing Services
• Binary Data Services
• Data Types
  • datetime — Basic date and time types
  • calendar — General calendar-related functions
• Numeric and Mathematical Modules
  • math — Mathematical functions
  • decimal — Decimal fixed point and floating point arithmetic
  • random — Generate pseudo-random numbers
• Functional Programming Modules
  • itertools — Functions creating iterators for efficient looping
• File and Directory Access
  • pathlib — Object-oriented filesystem paths
    (tempfile — Generate temporary files and directories — Python 3.14.0 documentation)
• Data Persistence
• Data Compression and Archiving
• File Formats
  • configparser — Configuration file parser
• Cryptographic Services
  • secrets — Generate secure random numbers for managing secrets
• Generic Operating System Services
  • time — Time access and conversions
  • argparse — Parser for command-line options, arguments and sub-commands
  • logging — Logging facility for Python
  • logging.config — Logging configuration
  • logging.handlers — Logging handlers
  • platform — Access to underlying platform’s identifying data
  • errno — Standard errno system symbols
• Concurrent Execution
• Networking and Interprocess Communication
• Internet Data Handling
  • email — An email and MIME handling package
  • json — JSON encoder and decoder
• Structured Markup Processing Tools
• Internet Protocols and Support
• Internationalization
• Program Frameworks
• Graphical User Interfaces with Tk
• Development Tools
  • unittest — Unit testing framework
• Debugging and Profiling
• Python Runtime Services
• Custom Python Interpreters
• Importing Modules
• Python Language Services
• MS Windows Specific Services
• Unix Specific Services
• Modules command-line interface (CLI)
• Superseded Modules
• Security Considerations

Point of Interest (to me):
There are modules I’ve used that I don’t have memorized (I mean placed in some sort of mnemonic palace/device), and a number of modules and functions and methods (etc) that I have memorized (ie placed in a palace/journey) that I’ve never used.

I like this.

I often feel like a detective having an a-ha moment anytime I watch a tutorial video on a module (or function/method/argument) I’ve memorized but haven’t used.
“So, that’s what that is!”

Python and Beyond

I’ve also been memorizing Object Oriented Programming concepts from the delightfully well-written Python 3 Object Oriented Programming by Dusty Phillips.

Related subjects currently memorized (in a palace/journey)

• git commands (very handy)
• Regex syntax (characters, quantifiers, whitespace, logic, and anchors and boundaries so far)
• Tmux shortcuts

..and Networking concepts
speaking of which…

Network Engineering

Almost more daunting, I began memorizing Todd Lamle’s CCNA materials at the start of January.

I admit, I took a week of very light memorization when my son stayed with me for a week the turn of the new year… also partially as self-congratulations. A lil breather.

I also purchased a book on Cisco’s Internetwork Operating System commands (the operating system used on Cisco routers and switches). So far, I’ve memorized mostly the main syntax for routing (and for switching in the numerous cases where the syntax is the same).

Networking Concepts

The list of memorized (ie, placed in a menmonic journey/palace) concepts is not short.
—This emboldens me, since it’s taking quite a while to tackle the breadth of the material.

Among the concepts that have comprehensive placements, there is:

Comprehensively memorized Networking & CCNA Subjects

• Layered approaches to communications reference models
• The OSI model and layers (and their DoD equivalents)
  • Application
    • DoD: Process/Application layer
  • Presentation
    • DoD: Process/Application layer
  • Session
    • DoD: Process/Application layer
  • Network
    • DoD: Internet layer
  • Data Link
    • DoD: Link layer
  • Physical layer
    • Dod: Link layer
• Ethernetworking
  • Collision domains
  • Broadcast domains
  • CSMA/CD
  • The duplexes
  • Cabling pinouts and standards
    • Straight-through
    • Crossover
    • Rolled
    • Fiber optic
      • (10Base-T, 100Base-TX, 10GBase-T, 100Base-FX, 1000Base-SX, 1000Base-ZX, 1000Base-LX, 1000Base-CX, and their key properties/characteristics)
  • Data Encapsulation (Ethernet_II frame properties, MAC address properties, etc)
  • Cisco’s 3 Layer Hierarchical Model
    • Core / Distribution / Access
• TCP/IP
  • TCP/IP and the DoD Model
  • IP addressing, terminology, and hierarchical IP Addressing Scheme
• Subnetting (so, binary, obviously)
  • Methods to do it.
  • The powers of 2 (up to the 16th power, aka 17th bit)
• and some other stuff here and there

I’ve spent extra time on the Subnetting techniques so that I’m capable of quickly subnetting Class B and C addresses completely in my head.

…well, I say completely. I actually use my fingers.

I link my fingers to a memory palace and do binary calculations on them.
I did binary on my fingers in the shower for fun the other day.
FINALLY checked that off my bucket list.

Math

In preparation for the journey I’m on, I’m brushing up on my math skills.

What math?

I’ve memorized the 15 chapter titles of an Algebra 2 textbook.
—Currently I have the concepts of Chapter 1 down mostly pat.
I’m casually working on my math palace. I’ve even got a section of town I’m saving for the probability and statistics textbook sitting by my pipe-smoking chair (tobacco pipe, dweeb). I just take walks and continue adding information to it a couple times a week.

Moving forward

In the immediate future (as in today and over the next week or two),

• my main focus is on CCNA.

I admit, I have a lofty goal of having my CCNA exam scheduled (not taken) by March 1st.

That ain’t no picnic.

and

I don’t like to do only one subject at a time.
I think I get a lot more memorized when I use this Bento method thing that I dig.

I’m choosing secondary and third focuses day by day.

• This week, my secondary focus is the Bash Reference Manual.

• And I’m expanding on my git commands, math, and regex.

Casually, of course. Not too crazy.

As for Python, I keep adding to it, but mostly I spend my Python time playing around with the code and things I’ve learned. I just started contributing to other GitHub projects (just typo fixes, nothing fancy). I’d like to ramp that up.

I finally got my neovim IDE functional again (working better than ever and with code completions and snippets). So, the coding time is fun and productive.

In the future

Immediate future plans hidden for the unusually interested to click on

I’d like to memorize UML and ER Diagram syntax (probly not the right word for that, I mean what all the various arrows and boxes and such mean).

I’ve also got what looks to be a stellar programming book coming in the mail. Highly recommended to me by someone who actually knows what they’re doing. That book should help me in more advanced programming conceptions, like constructing algorithms and real-world keystone gems.

I’m also planning to start glossing over Lua syntax to add to my palace so that I can utilize Hammerspoon (and all the other things that use Lua because it’s such a handy-dandy language).

I have plans that go beyond the next month, too.

But look how much I’ve written already. Good lord.

This is why I don’t sit down and do this very often.

I’d rather talk on the phone with coffee in hand. Or just go for a walk with my pipe in a town that has become very interesting to me since I began fantasizing all over the darned place.

Regards,
Beau

[beau2am]

Usually, and not always.

Let’s see.

For the networking material, I do quite a bit of preprocessing. I’m not brand new to the material (I studied it 15 years ago). So there’s already “preprocessing” if you look at it that way.

The Python documentation I spent time looking at the information and deciding on how to organize the many various parts of it as I went along.

For instance, I fed a list of Python’s built in functions into ChatGPT and had it do some organizing of the concepts in a way I felt would be productive and helpful.

So, even though the documentation lists builtin functions in alphabetical order, I have them memorized by “functional category.”

(eg, Logical and mathematical operations, numbers and bytes operations, character manipulation, sequences and data structures, etc.)

Just like we look things up in a book, we look them up in our heads. Except things can be looked up with the mind instantaneously (assuming you know it well enough). However, just like in a book, if you have to flip, page by page, to find a certain piece of information, that’s gonna be unruly if it’s… you know… a big book.

So much of my preprocessing is deciding on what sort of “index” I’m going to use.

Mind you for the 70 built in functions, and all of their individual methods arguments and parameters, and various signatures* I use a total of about 4 indexes to keep track and double check myself.

(a signature is one way to arrange arguments/parameters, and some functions —like the function bytes(), have 3 different signatures:

bytes(source=b'')
bytes(source, encoding)
bytes(source, encoding, errors)

note>

that’s from memory, so feel free to check my work. might be wrong. I’m very used to being wrong. So I’ve got that going for me.

Quite a number of functions have 2 varieties of signature (list, tuple, vars, int, next, etc all have 2 different basic variations for what parameters/arguments can be passed to them).
list()
list(iterable)

Some only have one variation, but they aint all daisies.
open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

that’s a busy function (and for good reason), plus there are 7 basic different modes to choose from. Not just ‘r’.
(There’s more than 7 really, because there’s combo modes like w+ and rb)

…
lest ye be doubtful the incredibly useful nature of appropriate and sufficient indexing, note that the string function str() alone has 48 functions of its own (called methods). Each with signature variations and parameters and arguments of their own (though none dressed to the nines like open() was).

bytes() is pretty much the same,
except where str() has .encode(),
bytes has .decode()

And there are like 68 more functions.

How to remember all that?

Well, the string function str() has its own index for its [48] methods, just like the 70 builtin functions have theirs.

str() is organized into groups like:

Case Manipulation:
[.capital(), .casefold(), .lower(), etc.]
Alignment and Justification
[.ljust(), .center(), .rjust(), .zfill()]
Search and Retrieve
[.count(), .find(), .rfind(), .index(), etc etc]
and others.

A total of
rolls eyes possessedly into back of head and counts
9 I think…
Let’s check:

1. Case manipulation,
2. alignment and justification,
3. trimming and stripping (calm down folks, they’re just string methods),
4. search and retrieve,
5. splitting and joining,
6. character checks,
7. modify and replace,
8. formatting,
   9.and encoding.

Yep. 9.

These categories don’t exist (not in this form in any way, at least) in the documentation.

This is the result of creative “preprocessing”. I think that’s fair and right to say. And I used ChatGPT on this one too (since I’m new to the material <both Programming and Python>, but I end up triple checking and doing multiple iterations to get a structure I feel good about memorizing).

For Bash, I jotted out the index names on a little notepad to take on my walk.

For Python’s Standard Library Reference (the structure specifically) I just carried my phone around with me and looked at it while I stared like a madman at nothing all over town.

So, yes.

But sometimes I just need to get something down, for whatever reason, or I just want to get started (you know, that irrational fire in the belly that makes you sick of sittin’ around).

Then I roll with it and just pick a palace (could be a new palace, might not be), and I start memorizing.

I take advantage of natural inclinations when they come around.

Thanks for the question!

Edit:
Mostly editing for copious typos, but also to mention that I also draw, write, highlight, scribble, color, and doodle in my reference materials (unless I don’t own them).

I let myself enjoy the process.

I also let myself fantasize. I mean really fantasize.

Sometimes horrible things. Sometimes unhealthily pleasing. Sometimes just plain wrong or hilarious or infuriating.

But as much as possible, I choose fantasies and images that are hard to forget.

I sometimes refer to it as “making fantasies unforgettable”, or sometimes “taking advantage of my own ability to react and be shocked.”

Just think of a time you saw or heard something so shocking you couldn’t stop thinking about it.

Boom. That’s the ticket right there.

[beau2am]

My pleasure!

[beau2am]

Saturday, February 3, 2024:

I memorized:
a structure for Regex commands (among other things)

I modified the structure for the rexegg.com cheat-sheet.

Resource Links

✽ Characters
✽ Quantifiers
✽ More Characters
✽ Logic
✽ More White-Space
✽ More Quantifiers
✽ Character Classes
✽ Anchors and Boundaries
✽ POSIX Classes
✽ Inline Modifiers
✽ Lookarounds
✽ Character Class Operations
✽ Other Syntax

Sunday, February 4, 2024:

I memorized:
commands for most characters, quantifiers, logic, whitespace, and anchors and boundaries.
(among other things, but this is about regex)

Today

February 8, 2024: I ran through all exercises (both basic and the advanced) available at regexone.com

It was my first attempt sitting at a computer and solving regex matching puzzles since memorizing regex.

I found, out of all the exercises, I only sought help on about 4 of the exercises.
The rest I was able to match, usually without reading the instructions/description provided.

Although the last 4-5 advanced exercises I allowed myself to read the descriptions. They didn’t provide as much help as I expected. Good, I thought. Then I solved them on my own by reviewing what I knew from my palaces.

I went through the exercises much quicker than expected, and I was able to access the palace and information within pretty quickly.

How?

What did I do right?
Well, not only did I add the information to Anki cards and have been periodically reviewing them, but, in addition, I had ChatGPT generate some beginner regex matching challenges (and corresponding solutions) and added the challenges to my Anki cards. I would attempt to come up with a solution speaking out-loud, then check the Anki card solution.

In a couple days I was quickly recalling how to put together regex syntax to solve a variety of beginner challenges like matching email addresses, phone number formats, etc.

Side-note:

I don’t like looking at a computer all the time.
A big focus of mine is being able to more-or-less visualize concepts, syntax, structure, etc.

I do a lot of driving (when I drive, it’s usually for some quantity of hours in a day).

Can’t be looking at screens while driving. But I can look at the inside of my head.

I did this with music some years ago, and now I’m seeing it can be done with programming too. Good vibes.

Edit:

Current Anki deck stats:

[myothersherlock]

I’ve also got what looks to be a stellar programming book coming in the mail

what’s the book’s name?

[beau2am]

Cracking the Coding Interview is the one.

I’m reading several other books as well.
Such as The Code Book by Simom Singh, Godel Escher Bach by Hoffstadter, and The Cuckoo’s Egg by Cliff Stoll.

And working through Programming in C by Stephen Kochan.

There’s a lotta books round here it seems.

[beau2am]

Also working through this one:

Python 3 Object OrientedProgramming
by Dusty Phillips

real solid. I memorized much of the first couple chapters and it’s really helped me conceptualize the OOP style and apply it better

[beau2am]

@anon83952945

Doh, I was just about to guess the book title:

I mean, you’re not totally wrong.

I purchased my OOP book (the Dusty Phillips one) and started it back in December.

Your guess is only two months late. Not bad!

[eir]

For regex, regxr is pretty cool as you get to play around with your expression in real-time.

Read that you’re interested in C as well, you may be interested in Beej’s Guide, which is a neat introduction to low-level networking.

For more of python, you may be interested in mypy / typing.

For more general programming, you may be interested in the “Make illegal states unrepresentable”, as well as functional, and data-oriented programming paradigms.

This is some really incredible progress, Beau!

[beau2am]

Thank you, @eir

I really like what I saw in Beej’s guide. I looked everything up you mentioned and appreciate you for the solid recommendations.

[beau2am]

Too many memory palaces.

Okay, not too many.

For the past month I’ve added more minimally to my memory palaces.

Instead, I did too much programming and experimenting with a bunch of the documentation and imagery I’ve littered my mind (and town) with.

I still find myself amazed at having so much memorized that I’ve never used.

Often when I do tutorials or experiment, it feels like a special sort of “Okay, Let’s Connect the Dots” learning session.

Challenges I’m facing are mainly in actually reviewing all the memorized materials in an organized fashion other than just the anki flash cards.

. Refiguring .

For programmers, when your code grows so extensive that it becomes difficult to read or understand, they rewrite and reorganize the code.

They call that process of rewriting and reorganizng, “Refactoring.”

I’m borrowing that term. But I’m from Texas.

So, I refer to the process of rewriting and reorganizing memory palaces as Refiguring.
(pronounced: re-figur’n, because that’s how Texans say it)

Not satisfied with merely experimenting, I have two books in my personal library that I’ve recently read through:

• Introduction to Indexing and Abstracting, Third Edition
  by Donald B. Cleveland

and

• The Organization of Information, Second Edition
  by Arlene G. Taylor

If I don’t have to, I’m not interested in reinventing the wheel.

Although there are clearly differences between memory palaces, card catalogs, XML, SQL databases, and etc etc, there are definitely some intersections in functionality.

Querying vs Browsing.

Search and Retrieval.

Keywords vs Phrases vs Hierchical vs Relational, etc etc yada yada

With copious notes on a bundle of papers, I’m attempting to do my own little essay to clarify my ideas and research so far on the topic of “refiguring” memory palaces.

One of my strongest memory palaces is the 70 built-in functions in Python.
For that memory palace (and I’ve mentioned this before), I have around 4 separate “indexes” memorized.

With this firmly planted in my mind, my conclusion is:
“Never underestimate the power of sufficient indexing.”

For my purposes, maintaining an expansive network of palaces is a far higher priority than speed.

There’s a tradeoff that happens between the two.

I suspect that if I can refigure my palaces with proper indexing (so to speak), I can expand the palaces faster, more comprehensively, with less forgetting, and more cohesion (and less ambiguity in the imagery I use for different topics).

[beau2am]

Looks like it’s dodecahedrons all the way down.

I began officially experimenting with a global scope mnemonic palace today.

You know, one palace to rule them all.

I prefer practicality, but on my mnemonic journey I must note to myself that I’m cautiously psyched about the system in its seeming simplicity (to me) plus the absurd scalability.

Perhaps my first stumble onto isomorphic delight was when I realized the Circle of Fifths I’ve long memorized, fit beautifully overlaying a clock. And thus I have had the habit for some years of referring to intervals by the number of hours you move forward or backward on the Circle.

a Major Third is 4 hours in the future.
a Fourth up is an hour back.

Mix that with calendars, seasons, datetimes for identifiers, and a never ending Russian Doll of dodecahedrons and topics and themes of all sorts, and that’s the sort of bizarre but delightfully personalized system I appear to be cooking up for my own use.

If this pans out and I end up documenting it, I’ll create a separate journal so as not to muddy up this one with only peripherally related ideas.

[beau2am]

Today I refigured my alphabetical index of Python 3.12’s built-in functions (there’s 70).

Here are 4 (mnemonic) indexes I use with the goals of:

1. locate functions by Functional Category
2. locate functions by name
3. locate functions Alphabetically
4. know all arguments for each function (and all available variations of arguments taken, ie, their “signatures”)

Index 1: by Functionality

---

organized in in a 3 layer hierarchy

• Overarching category

  • Functional Category
    • Actual Functions (not listed below)

• Fundamental Concepts:

  • Logical and Mathematical Functions
  • Numeric and Byte-related functions
  • Character Manipulation functions

• Data Structures and Collections

  • Collections and Sequence Functions
  • Iteration and Access

• Object and Type Handling

  • Object Properties and Introspection
  • Class/Type Management

• File and System Operations

  • System/Module Utilities
  • File Operations

• Advanced Programming Concepts

• Code Development & Execution

  • Code Processing
  • Debug/Dev tools

• User Interaction and Output

  • interactivity
  • printing
  • formatting

_

Index 2: by Number of Variations of Minimally Required Signatures

----

• Functions with a total of 3 signature variations (only counting the minimally required arguments)
  • Example: min(), max(), dict(), bytes(), bytearray()
• Functions with 2 total signature variations
  • Example: complex(), int(), str(), list(), etc…

_

Index 3: by Number of minimally required available arguments—with argument names

----

• 5 or more:
  • 8
  • 6
  • 5
• 4
• 3
• 2
• 0

_

Index 4: by Number of Functions starting with a particular character or letter

----

(example:
8 functions start with ‘S’;
6 functions start with ‘A’, 6 with ‘I’;
5 functions start with ‘B’, 5 with ‘C’;
. . .
2 functions start with ‘G’, 2 with ‘T’;
etc)

I use a sentence style index in descending order.

The order of letters, in descending quantity of function names starting with the letter:

• S: (8 functions start with S)
• A, I: (6 functions per letter)
• B, C: (5 functions/letter)
• D, F, H, M, O, R: (4 functions/letter)
• E, L, P: (3 functions/letter)
• G, T: (2 functions/letter)
• N, Z, _: (each has only one function starting with that character)

My sentence index works with this information.

• 1st word: starts with ‘S’ and is 8 letters long

• 2nd & 3rd words: start with ‘A’ and ‘I’ and are each 6 letters long

• 4th & 5th words: start with ‘B’ and ‘C’ and are each 5 letters long

• D, F, H, M, O, R: there are 4 functions for each letter.

  • Because of that, I created a separate phrase using ONLY these letters (I used a Letter Bank, which is like an anagram but you can repeat letters)
  • My phrase for these: “Horror, Mr Frodo”

• E, L, P: have 3 letters per word (ie, 3 functions per alphabetical starting letter)

• G, T: both words are only 2 letters long

• N, Z, _: each of these characters is only associated with 1 function.

  • The words chosen are arbitrary, as these come last in the sentence. If they kept with the pattern they would only use one letter apiece, but it’s pretty clear why something like ‘New Zealand__’ is appearing at the end, after the two letter words…

_

[BarKeegan]

What’s your method for memorising all that abstract syntax, and meaning of characters.
My arty brain just sees crocodiles chasing spiky stars and vertically flying seagulls across a line…

[beau2am]

@anon83952945 I’m still playing around with ideas.

For refiguring, so far, I’ve only done it on a smaller scale (adjusting a few locations and the imagery within them at one time).

For this, I find that just writing a list of what each area contains is helpful. I can reduce redundancy, clarify any ambiguous or confusing imagery, and generally “clean up” the scenes so they’re easier to remember.

For larger refigures, I haven’t done that yet.

I’m experimenting with drawing out various memory palaces on graph paper so there exists a “mapped” version I can refer to.

@BarKeegan : It depends on the syntax. For instance, I understand when I’m referencing Function_A() versus the arguments taken by Function_A() by the order they’re placed in.
For one-off functions or methods, I use a Cauldron as a signifier for “callable” objects, and the imagery in the Cauldron indicates the arguments or parameters taken by the Callable object.

Also, I have Python documentation memorized for how different types of objects work in the language.

All I need to do is remember that I’m using Python, and the syntax can explain itself (like Dunder methods).

For Networking concepts and protocols, I organize the information spatially. I can remember that this information is related to Layer 2 of the OSI because everything in this location is related to Layer 2 of the OSI.

For other syntax, like RegEx or tmux shortcuts, those have specific locations (and the rules for assembling syntax correctly is kept in the same location, or explicitly linked through association).

Edit: Oh, and I use crocodiles and seagulls as well for comparisons < > <=, and != is a hanged-man with two arrows sticking out of him.

[beau2am]

In Python, the open() function is used to open files. It has several modes to specify how the file should be opened:

•	r : Read (default mode)
•	w : Write (truncates the file if it exists)
•	x : Create (fails if the file exists)
•	a : Append (write data to the end of the file)
•	b : Binary mode
•	t : Text mode (default mode)
•	+ : Update (read and write)

I realized there were 7 basic ones: r, w, x, a, b, t, and +… There are also 7 notes in the major scale (music),

To remember the open function’s modes, I use a journey method: visualizing the F major scale on a guitar being traversed by… my fingers.

Each mode (for the open() function) I associate with a specific note and a finger action.

I’m combining musical notes, physical actions, and vivid imagery along a sequence/path I know very well in a different domain.

There is an element of isomorphism happening.

7 notes : 7 modes for the open function
(a one to one correspondence)

The journey is the major scale starting at the low F on my guitar. For each note of the scale-shape, a finger “plays” each “mode”.

1. On F I open a book with my pointer finger.

2. On G I write with a pin using my index finger.

3. On A I make an X with my pinky.

4. I move to the low B on the A string and upend (append: ‘a’) a desk

5. which tosses binoculars (binary: ‘b’) into the air and into my imaginary hands where I’m “standing” on the C note

6. and I look through them ahead of me at a cross burning (‘t’) on D, (which repeats itself on the open D )

7. and is immediately followed by a zombie coming out of a grave on E.

That’s the C scale, but I often do the F major scale instead (so there’s a Bb).

In a broader sense, isomorphism refers to a mapping between two structures that preserves relationships. In my case, I’ve mapped the structure of musical notes and guitar playing to the structure of the Python open function modes (maintaining a one-to-one correspondence).

I rarely use most of those modes.

But I memorized them this way back in January.

In essence I’ve “chunked” the seven modes into a sequence of actions tied to musical notes.

I make the journey with my fingers along a route I know, at least before it gets real dreamlike (but memorable).

Finding intriguing one-to-one mappings from different domains (ie isomorphisms) is handy dandy. I do it with a number of other mnemonics. I’m not sure how many though.

[beau2am]

I’ve started working through Robert Sebesta’s Concepts of Programming Languages.

I’ve been combing through a JavaScript book and periodically glancing at other paradigms and language constructs.

Breaking down programming languages into their component parts sounds to me a way build a framework for memorizing them more completely and potentially quicker (among other advantages).

I’ve got The Little Schemer in my office and I’m enjoying Eloquent JavaScript.

Onwards and upwards.

[Bsaturday]

The Little Schemer is a very interesting book.

I don’t mean any offense in the following question, I’m just curious: why are you memorizing documentation of programming languages? (I didn’t read this entire journal, I just skimmed, so perhaps you answered already). I’m probably going to memorize the NIST CSF the CCM (cybersecurity frameworks), so perhaps I’ll answer the question myself

I do find your note about open() modes and musical notes quite interesting.

[beau2am]

Thanks for the question!

To be fair, I haven’t explicitly shared the totality of my motivations.

Hopefully it will suffice to say that I have what I call a “10 year project” I’m working toward.

Part of that project entails slapping together a holistic conception of computer science topics.

I’ve gotten a bit of “flak” (as I perceive it) for “memorizing documentation.” Particularly from developers.

However, I come from an acting background. I don’t have “programming friends”.

In acting, yes, the best actors “memorize” their lines. But that’s not why they’re the best or why they’re hired. Anyone can “memorize lines.”

Memorizing lines isn’t even the finale of an actor’s work. If anything, the best actors really start the real work after they memorize their lines.

Memorizing is merely a prerequisite for getting real work done.

As an actor, once the lines are in your mind and body, then you can play with the material.

That’s when you can do the real work of exploring and experimenting without needing to stop every so often to walk across the room and pick up your script, or call out “line!”, or look up the documentation.

If you couldn’t memorize lines, then you would take other approaches. I wouldn’t say you’re totally out of luck.

But if you can, there are innumerable advantages.

And I can. So I am.

[homchange (ggnewark)]

Memorizing the entire book is impressive, but I think skill growth relies on practice.