I recently came across a very interesting connection (thanks to Obsidian) between computer science and knowledge management, which I’m sure anyone here can appreciate. I’ll start with a quote:
“Managing complexity is the most important technical topic in software development”. – Code Complete: Design in Construction
Developers deal with managing a huge amount of information, across a huge number of files, with a huge number of interconnections between them. The point is whatever systems they use have to be maintainable and efficient, so there has been a lot of work in that direction. PKM may not have a one-to-one connection with managing complex software, but there is enough overlap that it is worth drawing connections.
OOPKM
As you may know, Object-Oriented Programming (OOP) is one of the most popular tools for managing this complexity. It is a way of framing information to make it easier to write, read, manage, reuse, etc. (which are all valuable qualities in note taking as well). It is definitely worth knowing about.
Note: The goal here is not to turn notes into code, it’s to contrast the two to see what ideas can be transfered.
Note: All of this is much easier to apply to notes on topics that are more formal and exact (anything close to science). It will take some imagination but maybe personal notes can benefit too.
Note: Assume there is no object state and any computation is described in words
Here are some connections that are not complete yet to start a discussion:
Classes and Instances
- Let’s call every note a class and when it used in another note an instance
- Classes have properties, constructors, and functions
Inheritance
- A note can be a subclass of another if it has a “is-a” relationship
- A cat is an animal. A function is a set. An electron is a particle
- If it’s particularly important then expand it: A cat is a feline is an animal
- Using an Interface for different relationships
Encapsulation
- I would say the lesson from encapsulation is to define a good public interface for your note. In other words: have a note outline at the top of things you expect to use elsewhere, and not internal “private” functions.
Hierarchy
I’ve tried to connect these with the IMF system by @nickmilo . I agree that categories and heirarchies are not bad, they just need to be flexible.
- Package: A collection of namespaces (similar to an Index)
- Namespace: A collection of related classes (redifined as a MOC)
- Class: An abstract data type (a note that is abstract)
- Instance: A specific instance (a concrete instance of a class)
A quick example of a note:
(It was at this point I realised why this isn’t talked about more)
[[SquareMatrix]]
Package: [[Algebra]]
Namespace: [[Algebra-LinearAlgebra-MatrixTheory]]
Base: [[Matrix]]
1.Properties:
Invertible
Whether the matrix is invertible
Symmetric
Whether the matrix is Symmetric
2.Functions:
SquareMatrix(N)
N: size of matrix
Returns a square matrix
EigenDecompose()
Returns the eigen decomposition
EigenValues()
Returns of list of eigen values
(Separate outline from implementation for encapsulation / header references)
3.Function implementations:
SquareMatrix(N):
Specific details
EigenDecompose()
Specific details
EigenValues()
Specific details