Isn't note taking inherintly object oriented? [Solution: It's circling Ontologies]

[werererer]

TL;DR

TL;DR: Notes = concepts. Titles are not meaning but pointers. Inheritance in programming and psychology’s semantic networks both suggest how Trilium could align with knowledge structures. Below, I share some thoughts, and hope to reveal a bigger pattern in knowledge organization.

Isn't note taking inherintly object oriented?

Let’s talk about the structure of semantics (Meaning) in the context of note taking. I assume a setup where each note refers to a concept, while the title of the note is just a name for that concept or maybe a help to remember that concept again. I just want to give some food for thought on how our semantic knowledge might be built up.

That is: we assume that "Title" refers to a meaning, but isn't the meaning itself.

Semiotic Triangle

Further reading material: The Meaning of Meaning ¹

Some Structure of Meaning

If we have the following structure:

It follows, that:

However, the note Arms will not be the same as in the case Human, but will be implemented slightly differently.
What I noticed is that it is extremely similar to three concepts:

In Programming

Inheritance:

²

In Psychology

Standard literature: Principles of Semantic Networks ³

• Khan Academy ⁴
• KL-ONE ⁵
• Frames (AI) ⁶

The same concept can also be found in cognitive psychology:

⁷

In cognitive psychology, semantic networks use feature inheritance (Merkmalvererbung): properties of a super-concept are passed down to its sub-concepts through relations such as is-a (class membership, e.g., a sparrow is a bird) and has-prop (property assignment, e.g., a bird has wings). In this way, knowledge structures capture both category hierarchies and shared attributes — just like in our note structure.

In AI

Frames is technically an AI concept ⁶

Conclusion

There are a lot of concepts across domains circling the same question: what is the structure of meaning?

This makes me wonder if knowledge is inherently hierarchical and networked (with is-a and has-prop relations), and whether certain features from programming could help us improve how we think about notes as semantic capturing devices.

Why is it Relevant for Trilium?

Understanding the bigger picture of how Meaning is structured could help align future features in Trilium with established scientific principles of knowledge architecture.

In addition, every individual workflow ultimately captures meaning — and anything meaningless, by definition, cannot be captured (Wittgenstein, Tractatus Logico-Philosophicus, Proposition 7 ⁸⁹). If we architect Trilium according to the architecture of meaning itself, then any workflow that captures meaning will naturally align and work.

Appendix

Further interesting Concepts to read about:

In Linguistics

• Polysemy and Homonymy (How to differentiate the meaning of words with the same Syntax)
  https://www-users.york.ac.uk/~ez506/downloads/L140%20Handout%20-%20homonyms.pdf
• Synonyms (When are two words actually synonyms)
  • Partial synonymy
  • Total synonymy
    https://translationjournal.net/journal/42synonymy.htm?utm_source=chatgpt.com

In Computer Science

• WordNet
  https://wordnet.princeton.edu/
• Knowledge Graphs
  https://www.ibm.com/think/topics/knowledge-graph#:~:text=A%20knowledge%20graph%2C%20also%20known,illustrates%20the%20relationship%20between%20them.

Biology

• Taxonomy (how we arrange it)
  https://www.igntu.ac.in/eContent/IGNTU-eContent-310821034528-B.Sc-EnvironmentalSciences-4-ManojkumarRai-SystematicsandBiogeography-1-3.pdf

Chemestry

• Nomenclature
  https://iupac.org/what-we-do/nomenclature/

In Philosophy

• Ontology (what we capture)
  https://philpapers.org/archive/SMIO-6
• Meronymy and Holonymy
  https://en.wikipedia.org/wiki/Meronymy_and_holonymy

Resulting Questions

• How to order Notes that are in different Language but have the exact same meaning between two languages?
• How to use Notes to actually Learn concepts? That is, by actually explicating the underlying psychological structure one wants to - - recreate in the own head, talking of semantic networks.
• How to do collaborative Note taking?
• How should search algorithms work for finding notes, and how a user annotate his notes to make them findable (e.g. he could - use tags, or just the title, maybe the content of the note)?
• Can notes think?
• Can notes help creating more precise output? How to scale that?

Footnotes

1. https://pure.mpg.de/rest/items/item_2366948/component/file_2366947/content ↩

2. https://dev.to/m__mdy__m/exploring-inheritance-in-object-oriented-programming-k0e ↩

3. https://doi.org/10.1016/C2013-0-08297-7 ↩

4. https://www.khanacademy.org/test-prep/mcat/processing-the-environment/memory/v/semantic-networks-and-spreading-activation ↩

5. https://en.wikipedia.org/wiki/KL-ONE ↩

6. https://en.wikipedia.org/wiki/Frame_%28artificial_intelligence%29 ↩ ↩²

7. https://www.mdpi.com/1099-4300/12/5/1264 ↩

8. https://www.gutenberg.org/files/5740/5740-pdf.pdf ↩

9. Wittgenstein says: Whereof one cannot speak, thereof one must be silent. ("Wovon man nicht sprechen kann, darüber muss man schweigen"). ↩

[kde-baskets-user]

Interesting topic - thanks! I don't have answers, but it's still easy to respond.

OOP in programming: while it's true that OOP is a dominant methodology and students are often taught to follow its principles rigidly, the reality is different. The main goals of OOP are code reuse and extensibility, but it's just one of many ways to achieve those goals. Some languages, like functional ones, provide other means and don't need OOP at all. On the other hand, even OOP languages have many concepts that don't map one-to-one to OOP or even contradict it. One simple example: a Help Browser might internally use a web‑browser component to render help pages (an “is‑a” relation in design) but remove or disable all extra browser features, resulting in broken inheritance strictly speaking. In short, OOP has its place, but it's far from being a universal concept.

Frames in AI: I've seen frames in books from the 70s, but I'd assume they are mostly irrelevant and forgotten in mainstream research nowadays.

Hierarchy is a very useful modeling device in many contexts; it's often the first tool we reach for. If your task admits a clean hierarchy, you're in luck, but it quickly hits its limits. Even organizing files on a FS: where do you put a music file — MyFiles > mp3 or Music > Rock?

Semantic graphs: today there are broadly two branches of AI — machine learning and symbolic/logic inference (see ASP, etc.). These systems are often very successful and present knowledge as sets of predicates. Long story short, semantic graphs as objects and relations between them are indeed a powerful device to model the bulk of knowledge. Again, there are alternative representations and extensions that aren't, if at all, easily presentable as semantic graphs.

In your example you used predefined relations like hasprop and isa; they are, of course, useful but not that special. Second‑order logic allows you to define them from more basic ones as well as many other alternative OOP‑like relations and axioms.

How'd you store a weather prediction or a GPS location known only to within say ±20 meters? - just to give you one example of semantic graph limitations. In general, semantic graphs are not the best choice for incomplete, contradictory, unreliable, or imprecise data - in other words, for most real-life scenarios. Imagine for a sec a blurry or distorted semantic graph to accommodate such data.

Regarding meaning: If we define knowledge in terms of the logic-inference AI branch, why not define the other missing part - meaning or understanding - in terms of the opposite branch, machine learning: as values of thousand‑element vectors or tensors, called embeddings, that we train NNs to calculate. When an NN calculates the "embedding" of a given image or text, we say it understands what is depicted in that image or what the text is all about.

To summarize, while these concepts are uncertain and ambiguous in general, it's easy to follow practical and utility considerations by focusing on your task at hand. For note taking there are several methodologies like PARA (which is mostly hierarchical) or Zettelkasten (which is mostly graph‑based). A good note‑taking app supports at least one established methodology. So. instead of meaning of meaning you just ask how to better support this or that methodology. On the other hand, a good app for you personally mirrors the way YOU capture knowledge and work with information, which is different for each person.

[werererer]

TL;DR

Every workflow is personal, but ultimately built from the same set of primitive actions (just like every Lego build is unique, yet made from the same bricks). If note-taking systems ignore scalable, linguistically grounded ways of representing meaning, they risk collapsing as they grow. I’m not talking about features yet, but about the way we think about note-taking systems — because those assumptions shape the decisions and tools we build tomorrow.

Defense

Thank you for taking the time to reply!

Clarification about the "misleading title"

First, let me clarify one point: when I said “note-taking is inherently object-oriented”, that was more of a devil’s advocate stance to spark thought.

The truth is: object-oriented languages don’t actually follow principles from linguistics very closely. And of course, there are other paradigms — but in the end, every program can be reduced to a Turing machine anyway. Programming paradigms are just frameworks for thinking.

What I was really pointing at is this: people like to think in objects. We intuitively treat concepts as if they were entities with properties and relations. So when I said note-taking is object-oriented, I meant it more precisely like this: people might think of notes as objects.

---

While you point out interesting aspects, I want to counter a bit:

Most AI today that became mainstream is (correctly as you implied) subsymbolic AI. Defining meaning on a subsymbolic level naturally leads to a different view than defining meaning in the framework of symbolic AI.

I assume that humans think symbolically, which I infer from the fact that we use words to communicate with ourselves and others.

My defense

Primarily because I disagree:

To summarize, while these concepts are uncertain and ambiguous in general, it's easy to follow practical and utility considerations by focusing on your task at hand. For note taking there are several methodologies like PARA (which is mostly hierarchical) or Zettelkasten (which is mostly graph-based). A good note-taking app supports at least one established methodology. So. instead of meaning of meaning you just ask how to better support this or that methodology. On the other hand, a good app for you personally mirrors the way YOU capture knowledge and work with information, which is different for each person.

Let’s take your words seriously:

A good note-taking app supports at least one established methodology.

Note-taking methodologies are not well established outside the note-taking community.

In famous large-scale knowledge graphs, linguistic principles were used to structure meaning. For example:

• WordNet (~150,000 entries) ¹
• YAGO (~10 million entities) ²

Saying note-taking should not follow this path because they use “unusual code-based tools” is effectively saying that scalability is a non-issue in note-taking — and that everyone who produces a large volume of notes should be left with unscalable systems.

And saying a tool is “for researchers”, while dismissing researchers who study scalability, is effectively saying:
“This is not for researchers, it’s for hobbyists.”

---

Some Other Anti-Scalability Arguments

• “Notes should be in Markdown files, not in a database.” ³
  → Google doesn’t run its search engine on Markdown files — it runs on databases. (Luckily, Trilium does too, which is the main reason I’m here.) ^{4 5}

• “People who use different methods should adhere to standard procedures.” ⁶
  → That’s an argument against freedom of experimentation. But experimentation is exactly how new workflows and methodologies emerge.

• “The user could be hacked when running code.”
  → Security is a valid concern — but tools like Google Colab/Notebooks ⁷ allow code execution anyway. If an attacker is already running code on your server, the real issue is your security protocols ⁸, not the existence of code execution. Risks can be mitigated by isolating and locking down resources per user.

---

On the other hand, a good app for you personally mirrors the way YOU capture knowledge and work with information, which is different for each person.

Yes, of course I agree that people use different workflows. But every workflow is still just an encoding of some meaning structure — a subset of everything that can be expressed by structuring meaning in one way.

For example: I know someone who prefers “big notes” instead of breaking concepts down atomically. But if we both write down the same content, his approach is essentially just graph simplification.

Formally, this is edge contraction ⁹ (assuming you map syntax one-to-one to semantics): you take several nodes and the edge(s) between them from the original meaning graph and collapse them into a single node (the big note). The underlying graph of meaning hasn’t changed — it’s just been compressed, with less overlap between the note-graph and the meaning-graph.

---

For note taking there are several methodologies like PARA (which is mostly hierarchical) or Zettelkasten (which is mostly graph-based).

PARA is not designed for scalability. Based on sources ¹⁰ the author does not actively discuss large-scale scenarios, suggesting it has not been tested in that context. (I cannot prove that it fails at scale, but the evidence strongly suggests it was not intended for it.)

Zettelkasten: I think this is the first approach that should be taken seriously. It works, it’s elegant — especially in physical form — but I disagree with Luhmann’s method when applied to digital systems. (I have read through some hundreds of his notes and adapted some of his methods into my workflow.) Still, many digital implementations misapply it and call it “Zettelkasten” without following its principles. ¹¹

Summary

Every note-taking system that captures the full set of primitive actions (the raw act of encoding meaning) automatically supports every workflow.

So in the end, every workflow is just a different Lego build made from the same bricks.

That’s why the real challenge isn’t which methodology you adopt — it’s whether your system is built on a scalable, universal model of meaning. Without that, all methods collapse under growth. With it, any method can thrive.

Methodologies are temporary. Meaning is permanent. Scale decides who survives.

Appendix

I also think Zadam’s groundwork for Trilium was exceptional, making it, in my view, the only truly viable large-scale note-taking app available today.

Footnotes

1. https://wordnet.princeton.edu/ ↩

2. https://yago-knowledge.org/ ↩

3. https://www.reddit.com/r/PKMS/comments/1hltvgf/why_not_use_a_relational_database/ ↩

4. https://en.wikipedia.org/wiki/Database_index ↩

5. https://x.com/nalband/status/1625541479295860752?s=46&t=efB_T4Y8OoHj6BCmIMKASA ↩

6. https://www.reddit.com/r/college/comments/146tzmi/better_notetaking_methods/#:~:text=doesn't%20matter ↩

7. https://colab.research.google.com/ ↩

8. https://www.paloaltonetworks.com/cyberpedia/sandboxing ↩

9. Edge contraction (Wikipedia) ↩

10. https://umbrex.com/umbrex-presents/tiago-forte-building-a-second-brain/#:~:text=two%20notes ↩

11. https://niklas-luhmann-archiv.de/bestand/zettelkasten/zettel/ZK_2_NB_9-8_V ↩

[kde-baskets-user]

It feels like you argue with some other ppl mostly, not me. It also feels heavily LLM‑generated/edited.

I mostly recognize the ideas you talk about - the schools of thought and movements in different fields and the ages they originate from. I know they are/were huge and fueled a lot of debates in scientific circles. But I neither agree nor disagree with them, nor am I interested in arguing. Everything you said makes sense to some degree, but I don't believe any of these approaches can be praised as a universal formalism. From a practical POV, it's enough to be familiar with them in order to apply whatever device proves useful to solve the task at hand.

The only thing of substance I found in your response is a scalability property. But again, the way you talk about it feels off. Storing data in MD or a database, for example, has nothing to do with scalability per se. DBs are scalable because of indexes or caching they provide. But if an app builds caches or indexes "manually," it can be as scalable a solution as storing data in a DB. Ofc scalability is important, but sometimes not the most important property. Python is not a scalable language at all; it's easy to write small scripts, but it is hard to write professional software because of its untyped nature, but billions of ppl learn it at any given moment, perhaps only to use it for a few months and move on.

The other thing I found amusing is WordNet. 15 or so yrs ago, when I worked with it, it was an everyday staple in the scientific community. Now I learned the project is discontinued, implying that the whole era in scientific thought WordNet refers to is quietly being phased out, if not gone already.

Lastly, you throw vague Wittgenstein‑ish ideas as if you're not familiar with the whole post‑structuralist school and what they say about his work. You are most likely more versed in this field than I am, but just in case you aren't, you might want to look into post‑structuralist works, they had a lot of relevant and ground-breaking ideas as well.

Cheers.

[werererer]

Lets leave it at that, Thank you for a counter view!

[werererer]

Thinking a bit. I think I found a simple word encompassing everything I said: Its just Ontology.

Here is a good video:
https://www.youtube.com/watch?v=PrLY3Gzj6w4&ab_channel=HuBMAPConsortium

Here is the current most standard software for ontologies:
https://www.youtube.com/watch?v=LQ4iW3PO36E&list=PLViOSzHacrYkif3om_xwNOg4MKEFcBofg&ab_channel=TheAI%26DSChannel
https://protege.stanford.edug

Since I am only interested in note taking I will try to use it next to trilium to compare their capabilities. thus: ontology engineering becomes just note taking.

This is a standard what an ontology should be able to do:
https://www.iso.org/standard/74572.html

Sooo maybe this discussion can be closed, as I only see now two possible camps with lots of opinion variants: Either being practical or thinking about it more abstractly.