Slowly making your Obsidian automated maps of content hand-crafted

This is a post about Maps of content an idea in the theory of Obsidian by readwithai (X, blog).

I have started using Obsidian: it’s a fun note taking app that lets you build your own “web” of knowledge sort of like Wikipedia. This note is about using Obsidian better but if this makes no sense and you are still interested you might like to start here.

When you start making notes on a topic you often don’t know what structure you should have in your knowledge base to store them, so it can be convenient to quickly add a tag or a parent to a note so your notes have a bit of structure. You also don’t necessarily want to be distracted from the note that you are taking by maintaining structure. For this sort of thing, automated maps of content can work well, and are fairly straightforward to create with a saved dataview template like so:

```dataview
LIST WHERE contains(parent, this.file.link)
```

However over time it can be good to actually make these maps of content more “hand-crafted”. By hand-crafted I mean a map of content in which you have created the links by hand. The notes are then often ordered better, so that similar links are together and you have been made to think about how these ideas relate to one another. Also every time you look at this hand-crafted MOC you will remind yourself of this ordering and the process of making it.

One nice way of creating these handcrafted maps of meaning is to have a little sentence like the first paragraph in Wikipedia. It might looks something like this

Node is a [[runtime]] for the programming language called [[JavaScript]]. It funs on the server and can [[extensions written in C]]. It also supports [[JavaScript imports|imports]]

Going from automated MOCs to hand-crafted MOCs

An approach I have found of slowly moving between automated MOCs and hand-crafted maps is to have a dataview query at the end of your notes of all the child notes of your note that have not been manually added to a note (or a child note). This can be done with this query:

```dataview
LIST WHERE contains(parent, this.file.link) AND !contains(this.file.outlinks. file.link)
```

I then put this at the bottom of my MOC. Over time and when I think I understand the structure enough. I can add these links to the handcrafted part of a note and the links disappear.

A bit about the rule of seven

One thing you might like to do when you have too many notes with the same parent is add child “structure” notes to keep your links, so that you have a tree of notes. There is an idea that humans can hold between 5 and 9 things in working memory at the same time, so having around 7 links in each note in your map of content can work well. Of course, sometimes it good to have a nice long list as well

You can still output the complete tree under a top node with the following code:

```dataviewjs
function contains(property, link) {
	if (property === undefined) {
		return false
	}
	if (property.hasOwnProperty("0")) {
		return property.map((x) => x.path).contains(link.path)
	}
	return property.path == link.path
}

function children(p) {
	return p.file.inlinks.filter((x) => contains(dv.page(x).parent, p.file.link))
}

function makeTree(root, depth) {
	if (depth == 0) {
		return root.file.link
	}
	return [root.file.link, children(root).map((x) => makeTree(dv.page(x), depth - 1))]
}

dv.paragraph(makeTree(dv.current(), 2))
```

Finishing up

I hope you find this idea useful. If you are interested in this sort of thing you might like to:

1. Look at my review of note taking in Obsidian

2. Read my page on automated maps of content in Obsidian,

3. Look at my cookbook of tips and tricks for Obsidian.

You can also follow me on X where I post about various things. Or subscribe to my blog where I mostly write about research and reading with Obsidian.

Bibliography

Also linking your thinking has a lot of ideas about how note taking and thinking interacts