Improve Note-taking by Organizing Notes like Code

Note organization is very opinionated. There is no shortage of ways to organize notes and everyone seems to have their own method of doing it. Although these methods are great for the short term, as the number of notes grows it becomes difficult to manage notes with these self-made systems.

Funnily enough, the very same thing happens to programmers as well. As code gets more complex, it becomes harder to manage code. Now the difference between the two is that poorly managed code has real tangible consequences (e.g. more developer time = tons of money). Whereas the consequences of poorly managed notes are much less apparent (e.g. longer time to find information). For these reasons, I believe that code organization has innovated much further than note organization. So, there is much note organization can learn from code organization.

The Main Principle of Coding

One of the main principles of coding is to write code efficiently. One way to accomplish this is by applying the 3 R's: reuse, recycle, and reduce. By incorporating these three principles, we can make it extremely easy to find what we're looking for.

Reuse

Just like how we reuse water bottles, we can reuse our snippets of code with programming functionsprogramming functionsA function is simply a “chunk” of code that you can use over and over again, rather than writing it out multiple times. https://www.futurelearn.com/info/courses/programming-102-think-like-a-computer-scientist/0/steps/53095. Instead of copy-pasting or rewriting code, we simply "run the function" and the code snippet runs without any hassle.

Recycle

When finished a plastic water bottle, it might be worthwhile to repurpose it for something else (or just dump it in the recycling bin). Here's where recycling comes in.

In programming, recycling is as simple as updating or modifying a function. What's great about this is that updating the function updates all references to it as well.

Reduce

Using a reusable water bottle at all times eliminates the need for a plastic bottle; reducing overall consumption. When writing code, using functions makes reading code faster and easier. Long code snippets are summarized into a single line, reducing the amount that needs to be read.

Let's summarize the greatness

  • Less code to write (No copy-pasting or rewriting code)
  • Updating the function updates all places that reference the function (Update one = Update all)
  • Less code to read (Fewer lines of code with functions)
# greet function
def greet(name):
	print('Hello ' + name + '. Good morning!')
	print('Hows your day?')

# Let's greet everyone in 2 ways:
## Better way:
greet('Matt')
greet('John')
greet('Ethan')

## Worse way:
print('Hello Matt. Good morning!')
print('Hows your day?')
print('Hello John. Good morning!')
print('Hows your day?')
print('Hello Ethan. Good morning!')
print('Hows your day?')

How to apply these concepts to your note-taking

So you might be wondering, how can we apply these principles to note-taking? By using wikilinksbi-directional linksBi-directional links, also known as backlinks or cross-references, are links that connect two or more pieces of information in both directions. In other words, a bi-directional link allows you to navigate from one piece of information to another and back again. They can be a powerful tool for building a personal knowledge base and for making connections between related ideas. They can also make it easier to find and access specific pieces of information within a large collection of notes. in your notes! Wikilinks are essentially functionsprogramming functionsA function is simply a “chunk” of code that you can use over and over again, rather than writing it out multiple times. https://www.futurelearn.com/info/courses/programming-102-think-like-a-computer-scientist/0/steps/53095 but for notes.

Currently, in note-taking, most people write "spaghetti notesspaghetti codeSpaghetti code is a pejorative phrase for unstructured and difficult-to-maintain source code. Spaghetti code can be caused by several factors, such as volatile project requirements, lack of programming style rules, and software engineers with insufficient ability or experience. https://en.wikipedia.org/wiki/Spaghetti_code". It's no wonder most people find notes difficult to find and hard to organize.

But, by applying these 3 principles while using a link-based note-taking applink-based note-taking appLink-based note-taking apps are centred around the use of wikilinks. Wikilinks are typically created by surrounding the text with double square brackets. Some examples include but aren't limited to: * Obsidian * Logseq * Roam Research, you can un-spaghettify your notes! Here's how I incorporate the three principles in my simple workflow:

  1. Begin writing a note about anything (e.g. a thought)
  2. You come across a topic you want to expand upon (e.g. programming functions, wikilinks, spaghetti code)
  3. Search if the topic you want to expand upon already exists. Link it if it does.
  4. If it doesn't exist, create the link and expand upon the topic within the new note.
  5. Go back to the previous note and continue writing what you were writing

As you may have noticed by now, I'm using wikilinks in this blogThe New Way To Write Connected and Personalized BlogsSo originally my blog was hosted on https://thinkwong.com. It used WordPress which was good for typical blogging, but I wanted more than that. I wanted to demonstrate the effectiveness of connected notes and the best way to do that was to lead by example. Hence, I created a website with Jekyll using a digital garden template. And because interoperable components are efficient I write less while providing more value. Since content is condensed into atomic bits, I can create highly personalized b post as well. Use it as another example.