When I was a computer science student a friend told me: “Data structures and algorithms are the most important classes – pay attention in those.”

In retrospect I might have some qualms with this advice since the university had many classes that were well-worth studying diligently. But I took the advice and elevated my level of attention for those courses. Their concepts have stuck with me, albeit to varying degrees. One interesting set of concepts that has really stuck with me has to do with things called “pointers”.

Point! 🐕 🐝

Pointers are a type in programming and computer science. Other types that might be more familiar are strings (“fox”, “dog”, “jump”, etc.) or integers (1, 2, 3, 100, etc.). But instead of holding raw data like strings or integers, pointers hold the location, or “address”, of some other data. And because they store an address they can be used to chain data together in flexible and editable way. This is useful for building larger structures.

When working with pointers, there are generally two ways to handle them:

  1. Pass around the pointer itself.
    • Imagine being in a warehouse and passing around the location of a specific box’s location.
    • This is useful when searching for specific data nested inside larger structures, which are themselves, built from pointers.
  2. Access the single datum at the location the pointer is pointing to (this is called dereferencing a pointer).
    • Imagine going to the box’s location in the warehouse and retrieving what’s inside it.
    • This is useful for data extraction upon arrival at the desired location in larger structures.

“Pointers” and “pointer arithmetic” are famous for being difficult to learn1. So don’t worry if the ground we’ve covered still looks murky and unintelligible, especially if you haven’t studied computer science. Just remember those two bits mentioned above: That pointers themselves can be passed around and that they point to some data’s location.

And as complicated as they are, I’m starting to wonder if every single language-speaking human on the planet actually deals with these little guys every single day of their speaking lives.

Or at least with similar mechanics.

WikiWiki 🐝

As far as I can tell, in personal wikis and digital gardening the [[wikilink]] is the driving force behind these systems’ usefulness. And it shares a lot of similarity with the aforementioned pointer.

In these environments, whether you’re scripting some textual manipulation or typing up your notes or posts by hand, you will regularly think to yourself, “Should I add a link?” This seems strikingly parallel to point 1 above: You’re passing around a piece of data that points to some other data: When you type up a [[wikilink]], you’re in some sense creating a pointer to other data; namely a file filled with text.

So, it naturally follows, that either clicking on the link as the reader or even using mechanics like embedding or transclusion2 as the writer, is similar to the act of accessing the pointer’s data (or “dereferencing”).

So, if we have a [[wikilink]], then its pointer parallels might be:

wiki point
[[wikilink]] pointer
“wikilink” text address
wikilink.md file content data


Words, Words, Words 🐝

While wikilinks provide a direct parallel to pointers, perhaps this isn’t too dissimilar to how words work inherently. Think about it, words themselves are just this little piece of data. The power packed into a few characters almost never comes from the characters themselves, but the ideas that the word points to.

Of course, words are more [[word-atom|complicated]] than a single pointer directed at a single datum. I find it unlikely that pointers or computational nodes are a 1:1 representation of words or neurons in our brains, but the parallels are striking and it’s worth mulling over.

Who knows what other mysteries lie in the innerworkings of the powerful bits’n’strokes that can swoon hearts, change minds, and make or break entire worlds.

  1. It’s beyond the scope of this post, but it’s worth knowing that pointers are the base units used to build larger data structures like graphs. And, in reference to Joel’s perils’n’pointers-post, pointers and recursion fit together like a hand to glove. 

  2. These mechanisms insert the content of the target file in place of the [[wikilink]] instead of just hyperlinked text, which is the standard behavior. 

  3. There are also “double pointers” which are considered safer to use than just pointers. This strikes me as similar to using unique IDs like you might with something like the [[zettlekasten]] method.