In this post, I’ll give an overview of
Let's say you're in college, and you're trying to complete an engineering degree. To complete the degree, you have to take a set of courses.
However, you can't just take them in any order you want. Some of them have prerequisites.
In fact, some of them have a chain of prerequisites!
You can also have multiple prerequisites for each class.
This means determining an optimal order for your degree plan can get pretty complicated. Thus, a typical strategy is to identify the classes at the bottom of each chain and take them first.
Using the above example, we can model any college degree:
This structure is an example of a (topologically sorted) graph (i.e. a directed graph with dependencies).
A graph can also be helpful in understanding things on a smaller scale - including individual ideas. A topologically sorted graph of ideas is an example of a knowledge graph (for which, I don't believe there is a rigorous definition). Let's take this code for example:
let total = 0;
for (let i = 0; i < 5; i++) {
total = total + i;
}
console.log(total);
If you're familiar with JavaScript, you know what's going on here. It’s computing 0 + 1 + 2 + 3 + 4 and then printing it.
But, let's say you're not familiar. If I gave you the above high level overview of what that code does (i.e. computing the sum), it wouldn’t mean that you would then understand the details and concepts involved. Much like our college degree example earlier, there are a lot of prerequisite ideas that this “sum” code builds upon.
A similar knowledge graph would have the general idea at the top (in green), and all the prerequisite ideas below it:
Perhaps, after reading the code carefully, you've picked up on some of the lower-level concepts and increased the depth of your knowledge graph:
However, if I asked you to explain the code from scratch in laborious detail (without Googling), you would struggle (assuming you had no familiarity). Your knowledge graph isn't deep enough, yet, for that kind of fluency.
It’s no surprise that people have trouble explaining concepts they’re not familiar with, but a lot of people would argue that some knowledge, dubbed tacit knowledge, is intrinsically hard to communicate or explain.
I propose that there is actually no such thing as tacit knowledge. Just because we can’t explain it well doesn’t mean it’s innately hard to explain. What is tacit for one person might be very tangible for others.
In other words, it’s not the idea itself that is tacit. It’s us. More specifically, it’s the depth of our knowledge graph for the idea. If you can’t explain it simply, you don’t understand it well enough.
You might counter by saying that some knowledge is tacit. Let’s examine a common example of tacit knowledge: how to ride a bike.
It’s true that explaining how to ride a bike to someone who doesn’t know how will, alone, not succeed. However, I would argue that it’s because both the student and teacher don’t understand riding a bike well enough.
If you understand riding a bike well enough, there are plenty of ways to describe it exactly. One such explanation could look like this:
And so on. The explanation is specific, verbose, and complete (i.e. anything but tacit).
In fact, once we remove the channel (i.e. verbal instruction) as a factor, we uncover the real culprits that block understanding: a working memory bottleneck and lack of appropriate long term memories. If at least one of these limits didn’t exist, the knowledge could be communicated effectively.
For example, if the student had unlimited working memory, then, as long as the instructions were specific enough, delivering instructions to the student would be analogous to programming a computer.
Alternatively, if the student had an appropriate set of long term memories, such as riding a motorcycle, then the teacher could just say something like, “It’s like riding a motorcycle, except instead of an engine, you peddle.”
Let's go back to the code example:
let total = 0;
for (let i = 0; i < 5; i++) {
total = total + i;
}
console.log(total);
How would we enumerate the full knowledge graph for this code? Let's start with the fundamentals at the bottom.
...Well, hm. That's unexpectedly hard. We can go arbitrarily deep.
We can sink down to the hardware level. We can go deeper and talk about physics. We can get really meta. It's possible that this knowledge graph is infinitely complex.
This is a somewhat profound idea: it implies that, for any given idea, there is no such thing as "the fundamentals" - you can always deepen your understanding.
Perhaps what we know as "the fundamentals" from a given field are better described as the set of ideas that act as the greatest common denominators for the field in general. Another way of looking at it: the fundamentals are the set of ideas that act as minimally leaky abstractions for ideas further down the graph. These are ideas that you can trust to act as a foundation for more complex ideas.
Let us, instead, start at the top and traverse down until it stops seeming like a good idea.
The code does three things:
let total = 0
for (...)
console.log(total)
So, at this point, our knowledge graph looks like this:
Now, for each of our 3 nodes, let's talk about what concepts we need to understand them:
let
meanstotal
) istotal = 0;
) mean( ... ; ... ; ...)
) mean?i++
meanslet
means{}
) meantotal = total + i
)console
mean?log
mean?Here's what our updated knowledge graph might look like:
Wow, that's already getting really crazy. But, it's a good opportunity to point out how hard teaching actually is.
Because each student has a different proficiency, each of their knowledge graphs has a different depth. Worse, still, each branch of each graph has its own depth!
This means it's entirely possible for students to oscillate back and forth between bored and confused, depending on the lesson.
No wonder professors just give up and lecture. If they don't get it, they'll come to office hours.
Modeling information this way can be helpful in the following ways:
In fact, creating a knowledge graph for a particular idea is similar in spirit to something you’ve probably heard of:
The Feynman Technique
Structurally, the Feynman Technique is doing a breadth-first traversal of a knowledge graph, starting at the top!
Hence, an algorithm for helping yourself learn an idea might be:
Happy learning!
Thank you to the Compound Writing members who reviewed this post: Tyler Wince, Stew Fortier, and Patrick Rivera.