There are two concepts that blends together really nicely:
- Abstractions and Subpatches (e.g. in Max/MSP and PureData)
- Knowledge Graph (e.g. in Obsidian)
Imagine you are curious about how Minecraft's redstone circuits work. You first read the Minecraft Wiki, then make a little Patchies.app patch for a NOT gate to simulate it.
After a little bit of fiddling, it somehow works. On then off. Off then on.
Then, you realize each patch has an inlet and outlet. What if we connect them together into bigger circuits?
Alan Kay invented object-orientation and message passing. Object here refers specifically to mathematical and biological objects. The theory was based on how biological cells passes messages and signals to one another.
One of the principles in SOLID is LSP, the Liskov Substitution Principle. If the inlet/outlet types are compatible (i.e. if its messages share a compatible interface or trait), then you could substitute one object or patch for another.
That means if the inlet and outlet type line up, you can use that patch everywhere. In other projects and simulations.
What if each patch, including every subpatches, has its own link (e.g. https://patchies.poom.dev/p/biological-circuits) which acts as its identifier?
Then, you would be able to link or import any of those patches into other patches. In Max/MSP, we call this concept an abstraction, where you can import any other Max patches into another as an object.
Then, you could re-use and remix patches from other people's self-hosted Patchies Server for cross-federation, or just use the hosted Patchies repository (similar to OpenProcessing, or a GitHub for Git) as a repository or library of building blocks you can use in your own patches.
Back to the story. You try to import a NOT patch into an empty patch. That worked.
You then re-use the patches to build gradually bigger circuits, one building on top of the other. First, an OR gate. Then NOR, NAND, AND, NAND, XOR, XNOR gates.
RS latches. T Flip-Flops. Gated D-Latches. JK Latches. Then, Multiplexers. Randomizers. Adders. Decoders. Encoders. Buses. Relays. Pulse Generators. Oscillators.
Then, Half Adders. Full Adders. Carry Adders. Subtractors. Digital Comparators. Then, Memory Cells, RAM and ROM. Then, Registers, ALU, PC, IR.
You keep building more and more patches. You make small, reusable patches of each topics you've learned, with inlets and outlets that lets you control the simulation. An abstraction.
You gradually work your way towards a digital computer, like one would build in Minecraft. For each and every concept that you are learning about, you create a patch.
For every patch you build, you make sure to tag it like you would an Obsidian note, just for organization purposes. You tag it as #circuits to roughly link them together.
You could also make use of sub-patches for grouping. You put the redstone-related patches inside the main "Redstone Circuits" main patch just to organize it a little bit.
There's a reason why we create tags and not folders in Obsidian though. Folders limit the domain of your file. Tags encourages interdisciplinary thinking.
Remember the feeble NOT and OR gate? You of course start to see the same thing in pure mathematics when learning discrete mathematics. It's an abstract construct after all.
Then in biological circuits. Then in other places you did not expect.
You start to use the same "logic circuit" patch in other projects where you learn about completely disparate things. Just like software registries e.g. NPM in JavaScript, Cargo in Rust. Just because you think the patch fits.
After a while, you realize you can also visualize the relations of the patch, where you can see how abstraction, object tags, subpatches and object links are related.
You zoom out. A birds-eye view. You look at the big picture.
It's a graph. Like one you might see in Obsidian.
That graph tells you all that you need to know.
Regardless of where you started out from, whether it was Minecraft Redstone, Electrical Engineering, Discrete Mathematics, you see it in other places too.
Category theory teaches us that there is the core, and there is the context that surrounds those core. So did Zen buddhism: what are we but a skeleton that moves?
Once, nothing exists. And God said, 'Let there be light,' and there was light". But what is light?
An empty sheet of paper sits in front of you. You draw one little dot. You draw another dot. Then another. Then, more dots. Then, even more dots. You've seen so many dots.
A pattern forms in your mind. That looks like something you've seen before.
We tell ourselves story to not be afraid of the night. We see that little dot billion of years away. We give them names. We give groups of them names. It's a constellation of stars. For their children, and the next generations, continue to remember them for the next millennia.
Our life is a collection of little dots. A collection of decisions.
"Should I do this project with this friend?" "Should I go to that meetup?"
When we decide to do something, a dot forms. When we cry because an idea failed, a dot forms. When we laugh at us discovering a known theorem, a dot forms.
After a while, I stopped caring much about why I need to learn a specific thing. Sometimes, I just learn it just because it's fun. Just because it's truly beautiful. Just because I am curious about how that thing works.
Time passes. I then learn more things. More dots. Then I know.
A knowledge graph naturally form when you use patches, subpatches and abstractions. You tag them. You import them. You link them. You group them. You share them with others.
Even when you have code snippets that you use often. You tend to use the same pattern in many places, many projects. You capture the structure in the back of your mind, waiting for it to unravel.
I thought about this idea of knowledge graph that naturally emerges through building small, re-usable abstractions and simulations in Totality Editor, Simulate the Universe, Visual Assembly Canvas, Constella and Constella Telescope before.
I just think it is a genuinely beautiful idea.