Forem: Kevin Lin

Cache All the Things - A PKM workflow to incrementally retain (and find) everything

Kevin Lin — Thu, 29 Sep 2022 15:53:40 +0000

Context

An engineering manager that will remain unnamed told me his story of trying to find the solution to a technical problem on the internet.
It's the typical question -> google -> stack overflow -> answer pathway with a twist - when he finally found the answer, he realized that he himself had created the question a year prior.

I like this story because it's easy to relate to. Haven't we all searched for something that turned out to be a problem we've already encountered?

The process of searching for answers on the internet is what doing software (and much of knowledge work) is like in the 20th century.

There is an overwhelming amount of information we need to process just to do our job. It is impossible (nor useful) to keep this information in our heads so we rely on services like google to help look up what we don't know (or have forgotten).

While this can work, there is a problem when we come to depend on this workflow for getting through the day. It's like only relying on google maps to get home - while this works, you also lose the ability to navigate on your own in the process.

This is a groundhog day loop - regardless of how much you search, learnings are quickly forgotten and mastery is never built.

Now imagine the same workflow where instead of starting with a search, you look up information in your personal knowledge cache. This cache contains every problem you have ever encountered and is accessible in seconds. If you find the answer, you're done, and if not, you can be certain that it is not there. Only then do you fall back to search. When you find the answer, you add it to your cache so you can make use of it in the future.

This is a mastery loop - instead of losing your place on every question, you build and reinforce your understanding of things with each problem you encounter.

The key to building this particular mastery loop comes from combining the following PKM workflows:

a modified version of the progressive summarization method
A Hierarchy First Approach to Note Taking

Together, they let you cache all the things!

Progressive Summarization

If you're not familiar with the term, progressive summarization is the means of incrementally retaining insights from text to be used at a future date. It is built around five layers of summarization and pioneered by Tiago Forte, a big influencer in the PKM space.

The steps are described in more detail below:

If you come across useful information, save excerpts from it. This is layer 1. The benefit: next time you revisit the notes, you can just go over your excerpts instead the entire text.
If you happen to need the text again, bold specific passages that stand out as you're reviewing. This is layer 2 and serves to make future skimming easier.
If you require the text again, ==highlight from the bolded parts== insights that are especially poignant. This is layer 3 and it represents the highest quality insights that you've derived from the specific text.
If you still have need of the text, make a summary of it in your own words. This is layer 4 and represents the start of reframing the text in your own words.
If you then find the text relevant in some current project, the final step is to remix it into your own material. This is layer 5 and represents the culmination of all the prior layers.

There are some highly desirable characteristics of progressive summarization:

just in time vs ahead of time: you only do the work when you need to
incremental work: you only do minimal work at each layer which can then be leveraged in later layers
active vs passive: you actively read the text instead of skimming it

A Hierarchy First Approach to Knowledge Management

The Hierarchy First Approach to Knowledge Management excels at helping people organize lots of information in a consistent structured way for later retrieval.

It provides a foundation to create a knowledge base that can grow to any size while ensuring that information remains accessible. You can read more about the details of this workflow in the original blog post - It's Not You - It's Your Knowledge Base

Cache all the Things

Progressive Summarization helps with retaining key insights from text, the Hierarchy First Approach helps organize those summaries so that they can be found again later. The combination of the two lets us create a knowledge base of distilled insights that can be accessed at a moment's notice.

There are five levels to this hybrid technique and we'll spend some time explaining each in greater detail below.

Note
Expand
Split
Standardize
Refactor

Level 1 - Note

When you come across information that turns out to be useful, make a note of it. This is done by copying the relevant excerpts from the source material.

Greg is a new engineer at Literal, a social VR company. Their first assignment is to change a hard-coded welcome string to an internationalized string. Their mentor recommends using the CLI tool grep to find all instances of the string. Greg has never used grep before so spends some time learning about it. He captures a basic example of running the command in his notes.

## Synopsis



```
grep [OPTIONS] PATTERN [FILE...]
grep [OPTIONS] [-e PATTERN | -f FILE] [FILE...] 
```



## Example



```sh
grep 'python' *
```

Level 2 - Expand

If you find yourself continuously going back to the source material because you end up using more functionality, invest in adding more information to your note. For example, this could detail instructions for the new functionality or hard-won insights you've discovered through trial and error.

Greg finishes his first assignment and ends up doing more localization work. He uses grep quite a lot and discovers that he can use regex to speed up his workflow. He has also at this point noticed some mistakes he keeps making with the options. Greg makes a note of all of this.

## Synopsis



```
grep [OPTIONS] PATTERN [FILE...]
grep [OPTIONS] [-e PATTERN | -f FILE] [FILE...] 
```



## Gotchas

- large repetitions can cause memory exhaustion
- must escape `()|-` signs
- set option flags **before** the PATTERN

## Options

- \-P  use perl like regex (you can lookahead and lookbehind)
- \-i: Ignore casecase
- \-x: Force search to match line

## Example



```sh
grep 'python' *
```

Level 3 - Split

If you continue to expand the note, the note will eventually exceed the limit of a single page (eg. 800 words). At this point, you want to split your notes into smaller notes

NOTE: The process of splitting of large notes into smaller notes is also known as the amoeba pattern

Greg finds himself using grep all the time and he now has to spend time scrolling through his grep note to find what he needs. He has a section on snippets that makes up most of the note so he decides to split it off into its own note.

.
└── grep
    └── snippets

Level 4 - Standardize

As you continue the process of expanding and splitting notes, you tend to find certain clusters of notes will all have the same shape. When this pattern starts to emerge, you can standardize these patterns into hierarchies.

As Greg takes on bigger assignments, he also expands his arsenal of CLI commands. Greg realizes after a while that all CLI commands have a similar structure and so he consolidates it in a hierarchy.

.
└── cli/
    ├── grep
    │   └── snippets
    ├── sed
    ├── awk
    │   └── snippets
    ├── git
    ├── test
    └── ...

Level 5 - Refactor

In software engineering, refactoring is "the process of restructuring existing (information) — changing the factoring — without changing its external behavior"

Refactoring is done because the original structure can outgrow its usefulness. Sometimes the underlying information changes or your understanding of it does. Regardless, this means that you will need to update your hierarchies to account for this change.

Greg is tasked with a new assignment that involves working with windows and the PowerShell instead of the Linux terminal. He discovers that the PowerShell has its own set of commands and that the same commands in Linux will have slightly different behavior for Powershell. Greg proceeds to refactor his original hierarchy

.
└── cli/
    ├── linux
    │   ├── grep
    │   │   └── snippets
    │   ├── sed
    │   ├── awk
    │   │   └── snippets
    │   ├── git
    │   └── test
    │   └── ...
    └── powershell
        ├── CopyCmd
        ├── grep
        └── ...

Challenges

The workflow we just described can be applied outside of CLI commands to cover any information you might want to track. It allows you to systematically build up both your reference of "facts" in a domain as well as an underlying mental model of said domain.

The challenge in actually implementing this workflow generally surfaces in the latter two levels: standardization and refactoring.

Standardization into hierarchies is difficult because creating hierarchies is usually time-consuming and adds friction to both the retrieval and capture of new information.

Refactoring is hard because it usually relies on manually moving old notes into new hierarchies and also breaks links in the process.

This is why we created Dendron - a note-taking tool that helps people organize and refactor their notes.

By making it easy to standardize into hierarchies and refactor as needed, Dendron makes it possible to create, maintain, and make use of knowledge bases that span from a single README file to hundreds of thousands of notes!

Conclusion

Information can be overwhelming but it doesn't have to be.

We've long passed the point where we can keep everything in our heads. While that information is available on the internet, it takes time to find and is hard to retain.

By combining Progressive Summarization with a Hierarchy First Approach to Knowledge Management, we've created a workflow that lets us externalize an unlimited amount of information and the means to quickly find it again when needed.

This incremental caching of everything represents an escape from the endless cycle of searching for things we've already done and instead, lets us focus our efforts on the novel and bigger challenges of the day.

Imagine how much more effective we could be, as individuals, teams, and as a society, if we could build on top of what we knew instead of spending time forgetting and re-discovering hard-earned knowledge?

And now stop imagining and start caching!

Dendron 100

Kevin Lin — Tue, 21 Jun 2022 15:28:47 +0000

Dendron is launching on product hunt today. If Dendron has been of use to you, please leave feedback on our launch page - this would help us out a lot! 🙏

Context

Two years ago, we launched Dendron because we believed there was a better way of managing knowledge.

The problem - we are all drowning in information! Existing tools try to make it easy to get knowledge in but fail at getting that information back out when needed.

Dendron is a developer-focused, open-source, note-taking tool. It combines the simplicity of markdown with the power of VSCode. To manage information at scale, Dendron applies the insights we've learned from five decades of developer tooling and brings it to general knowledge.

Since 2020, we've been iterating on this thesis with weekly releases to make Dendron better, faster and stronger! With the v100 release, we'll take a moment to go over some highlights.

Better

In a well-designed system, easy things should be easy and hard things possible.

This hasn't always been the case at Dendron and it's something we've put in a lot of effort addressing through improved documentation, feature work, and better defaults.

Besides creating a catalog of talks and guides of how Dendron is used in the wild, we've also kicked off a standardization effort across all our docs so that any feature, command, or config is just a lookup away!

Feature wise, the following are some areas we've invested in to make common workflows easy:

the Dendron Sidebar provides one click access to most frequently used features like backlinks and the tree view
the Import Obsidian Vault command provides a one click method for importing your notes
the Help and Feedback panel provides a cheatsheet of useful resources and docs
the Tip of the Day panel highlights new features and enhancements

Finally, many of Dendron's core use cases now come with better defaults. For example, daily journals and meeting notes have built-in templates that get created the first time these commands are invoked.

Faster

Life is too short to wait for your notes to load.

Dendron has always been fast - much of this we get for free because your notes are just local plaintext files stored in your computer.
Over the past year, we've optimized all the parts of Dendron's lifecycle, which include initialization, lookup, publishing, and autocomplete just to name a few.

These changes resulted in orders of magnitude better performance across the board and <100ms of latency for the most common actions in Dendron 🚀 🚀 🚀

Stronger

Our goal is to make Dendron an IDE for knowledge.
Since 2020, we've released over 600 features to augment what you can do with plaintext.

Some highlights:

Handlebar Templates that allow augmentation of your templates with conditions, variables, and for loops
Hovers over links and backlinks
Note Traits that allow you to create notes with custom behavior
Publishing using NextJS with selective publishing

For the full changelog of all features, see the release notes.

Conclusion

Prior to Dendron, I worked at Amazon for over half a decade.
Something that stuck with me from my time there is that it's always day one.

This is especially relevant when dealing with knowledge management today because how humans manage information in the age of the internet is fundamentally an unsolved problem.
With Dendron, we think we have something that works.
Whether you are an individual managing a handful of notes or a team with tens of thousands of notes, Dendron helps you stay organized and on top of it all.

We've spent the past 100 releases iterating on our hierarchy first approach to note taking and we'll spend a few hundred more building on top of this foundation. On behalf of the entire Dendron team, I would like to say thanks to everyone that helped make this happen - chiefly our wonderful community and our steadfast investors. Here's to the next 100 releases!

Sincerely,

- Kevin

VSCode - Markdown Edition

Kevin Lin — Mon, 09 May 2022 15:57:50 +0000

With the 1.67 release, markdown gains programming language like tooling in VSCode

Specifically:

drag and drop files into the editor to create a markdown link
find all references to header|links|files|urls inside of markdown
rename headers|links inside markdown (and propagate the changes to all places where the link is used)
rename markdown files (and propagate changes to all links referencing said file)

If we move past drag and drop, it's notable that all other functions are related to referencing and renaming symbols. These are capabilities that are more commonly associated with programming languages than markdown.

A programming language is any set of rules that converts strings... to various kinds of machine code output

Wikipedia

Programming languages generally have a strict syntax that constrains the language. IDEs leverage this strict syntax to offer features to manipulate symbols within the language.

Markdown also has syntax (albeit more loosely defined) . This makes it possible to introduce similar transformations onto markdown.

The reason that this functionality is useful (and necessary) for programming languages is because codebases today can be massive, surpassing hundreds of millions of lines of code.

Repositories of markdown can also be massive. They are increasingly used to document and store general knowledge - both in the context of personal knowledge management (PKM) and team knowledge management (TKM).

For purposes of illustration - the primary vault (the circle titled private) for the Dendron team has over 400k lines of markdown.

The illustartion is generated using a fork of github's repo-visualization code, first described here

Running cloc returns the following output:

cloc --vcs=git .
github.com/AlDanial/cloc v 1.92  T=7.82 s (1472.4 files/s, 65739.6 lines/s)
-------------------------------------------------------------------------------
Language                     files          blank        comment           code
-------------------------------------------------------------------------------
Markdown                     11494         108500             19         404711
JSON                             3              5              0            369
YAML                            14              1              0            351
-------------------------------------------------------------------------------
SUM:                         11511         108506             19         405431
-------------------------------------------------------------------------------

Given the shared syntactical properties and problems of scale between programming languages and markdown, it makes sense that the same tooling can work for both.

VSCode, and IDEs more broadly, help developers manage large code bases by making available tools to leverage and manipulate the syntax of programming languages. By shifting some of this tooling to markdown, can we do the same for large markdown repositories?

Our bet at Dendron is a resounding yes! This is why we built our knowledge management platform inside of VSCode. By leveraging the paradigms from IDEs and applying them to structured markdown, our mission is to help humans manage any amount of information.

Writing a Visual Studio Code Completion Provider

Kevin Lin — Thu, 23 Sep 2021 16:43:43 +0000

Visual Studio Code (VSCode) provides many powerful features for extension developers. Autocomplete, warnings, tasks, and many more features are included out-of-the-box and are available for extension developers to take advantage of. However, figuring out how you can take advantage of these features as an extension developer can require digging through API documentation to learn the exact behavior. Using the API incorrectly can lead to issues that are hard to debug, as I learned working on the block autocomplete feature for Dendron.

This post is an overview of VSCode autocomplete —also called intellisense— feature from the viewpoint of an extension developer. I especially want to highlight a few pitfalls: VSCode provides defaults for many of the options around autocomplete, but the behavior of these defaults can be confusing if you don't know what they are.

Entry point

Your entry point into adding an autocomplete feature is languages.registerCompletionItemProvider. This allows you to attach a function that will generate the options when requested.

languages.registerCompletionItemProvider(
  "markdown",
  {
    provideCompletionItems: provideBlockCompletionItems,
  },
  "#",
  "^"
);

Above is how Dendron attaches the completion provider for blocks. This part is straightforward, although note the symbols at the end. These are the symbols that when written will trigger your completion provider automatically. While you can define multiple symbols, each symbol has to be a single character. If An overview & tutorial of writing VSCode completion providers (intellisense) as an extension developer

Next, let's take a look at the completion function. Here is the function signature for Dendron:

export async function provideBlockCompletionItems(
  document: TextDocument,
  position: Position,
  token?: CancellationToken
): Promise<CompletionItem[] | undefined> {

document and position are straightforward. token is used to cancel completions, for example if the user hits cancel while waiting for the completions. Key thing about the token is to remember that javascript is single-threaded: the token won't suddenly get cancelled in the middle of your function. The only point where it can become cancelled is if you await for something and yield the execution. This means you don't have to check if the token is cancelled everywhere in your code, just check after any awaited operation that might take a significant amount of time. Checking the token is easy, if (token?.isCancellationRequested) return; is enough.

The more important thing here is how the function gets called. One way the function will get called is if the user types one of the trigger symbols you registered. Another way is if the user hits the key for "Trigger Suggest" (Ctrl+Space by default), all registered completion providers for this language will run. Crucially, this means your completion provider may be activated at any point in the document, with or without your trigger key.
It's up to your implementation to check if the current position is somewhere that this completion is appropriate for, and return; if not. Let's look at a simplified version of how Dendron handles this for the autocomplete:

let found: RegExpMatchArray | undefined;
const line = document.lineAt(position.line);

// There may be multiple links within this line
const matches = line.text.matchAll(LINK_WITH_BLOCK_REGEX);
for (const match of matches) {
  if (_.isUndefined(match.groups) || _.isUndefined(match.index)) continue;
  const { entireLink } = match.groups;
  // If the current position is within this link, then we are trying to complete it
  if (
      match.index <= position.character &&
      position.character <= match.index + entireLink.length
  ) {
      found = match;
  }
}
if (_.isUndefined(found)) return;

The gist of it is that we get the text for the current line, and check if the current position is inside a link with a block that we can complete.

`CompletionItem`

`label`

A key part of the completion item is the label. The label is not only displayed for the completion items, but it's also used as a default for many of the options in a CompletionItem. The text that gets inserted when the user selects something, deciding the order in which these items are displayed, and how these options are narrowed when the user types are all based on the label by default.

`range`

The range is the most confusing part of the CompletionItem in my opinion. The range determines 2 things: where the selected item will be inserted, and also what counts as "stuff that the user typed to narrow the items".

For the first use of range, whatever range you provide will be replaced with the insertText (or missing that, label) of the completion item. If you have nothing to replace, the range can have start === end in which case the text is just inserted at that point.

The second use of range makes things a bit more tricky. Because the range determines what counts as "stuff the user typed", you have to be careful about what you include in the range. For example, Dendron's autocomplete allows users to type [[^ to get all blocks within a text as autocomplete options.

The problem? The user needs to type ^ to activate the completion, but ^ is not part of any completion item, and also ^ needs to be removed once an item is selected because the text is supposed to look like [[#^something]] after the completion.

While it would be convenient to just set the range to anything within the brackets, this will result in all completion items being narrowed out because ^ will also count as "stuff the user typed to narrow the items".

Something important to bring up here is the default for range. If you look
into the docs, you'll see that the default is the "range of the current word",
effectively the output of TextDocument.getWordRangeAtPosition function.
getWordRangeAtPosition allows you to set a custom regex to select what
"current word" means, so this might sound like a good way to calculate the
range. While this would work in some cases, I found that
getWordRangeAtPosition is extremely inefficient if your regex is more complex
than [...]+. Especially using lookaheads or lookbehinds causes VSCode to
completely hang. I'd recommend avoiding this function unless the default mostly
works for you.

`sortText`

This field is used to determine in what order the completion items are initially ordered. Initially is important here, as VSCode may move the items around once the user starts typing if it decides some items match the text better.

The annoying part about sortText: it simply sorts the items using basic string sorting. Issue here being that if you have a loop to generate your completion items, you can't just use the index to sort the items.

blocks.map((block, index) => {
  // These won't sort right, because "11" < "9" in string sort
  return {
    label: block.text,
    sortText: String(index),
  };
}

The fix is to pad your sortText.

sortText: String(index).padStart(5, '0'),

This is not a perfect fix of course, but it's unlikely that you'll have over 99999 completion items.

`insertText`

This is the text to be inserted when the user selects a completion. By default
it's set to the label, but you'll want to set this if you are using the label to
display something more informative to the user. For example, when completing
blocks, Dendron uses the label to display the actual line the user is selecting.
But the text we need to insert into the wikilink is not the same as the line
itself, so we set this to get it to link to the right place.

insertText: `#${AnchorUtils.anchor2string(anchor)}`,

`additionalTextEdits`

insertText replaces the part of the text that is selected by the range. This
is actually quite limiting: As I mentioned before, range not only selects the
what will be replaced but also what VSCode considers "typed by the user to
narrow options". What if you want something to be replaced along with what the
user typed, but you don't want it to be used in narrowing?

For example, when autocompleting for blocks in Dendron the user might type
[[^some-header, but the resulting link will look like
[[#some-header-text-here]]. We need to remove ^ along with whatever the user
typed, but if we set the range to include it then the narrowing would be
thrown off because it would look for options where the label includes ^.
To get around this, we use the additionalTextEdits to automatically remove the
^ part.

Another use for additionalTextEdits is to insert text somewhere completely
different in the document. Think of auto-imports for some languages, where you
type something and the language automatically adds import .... Or in Dendron,
if the user selects a block that doesn't already have a block anchor when
completing blocks, we need to insert a block anchor there. additionalTextEdits
have no limits to where they can put the text, as long as it's within the same
document. In any case, let's see what this code looks like:

const edits: TextEdit[] = [];

if (found.groups.trigger) edits.push(
  new TextEdit(
    new Range(
      position.line, found.index + 2,
      position.line, found.index + 2 + found.groups.trigger.length
    ),
    ""
  )
);

if (_.isUndefined(anchor)) {
  anchor = {
    type: "block",
    value: genUUIDInsecure(),
  };
  const blockPosition = VSCodeUtils.point2VSCodePosition(
    block.position.end
  );
  edits.push(
    new TextEdit(
      new Range(blockPosition, blockPosition),
      ` ${AnchorUtils.anchor2string(anchor)}`
    )
  );
}

The first part adds a text edit to remove the ^ part the user typed by
calculating the range from a regex match, then replacing it with "". The
second part adds the ^... part to a block by calculating the range from the
parsed document.

Conclusion

Autocomplete is a ubiquitous feature in text editing today, both for writing
natural languages and coding. It is an incredibly easy-to-use yet powerful
feature for your users, and it enables unmatched user experiences when done
right. But when done wrong, it can cause a disconnect and confusion around your
product. At Dendron, we strive for the former and hope that the learnings from
our experience will help you do the same.

Dendron - Super Fast Open Source Note-Taking inside VSCode

Kevin Lin — Tue, 16 Mar 2021 15:54:08 +0000

I started Dendron because I was frustrated with the lack of good note-taking tools while working as a developer at AWS.

I wanted something with the ease of notepad, the structure of evernote, and the speed of redis.

Iterating over these features for nearly a decade led me to Dendron and its been battle-tested with my own collection of 30K+ notes.

VSCode, Lookup, and Hierarchies

Dendron is built into VSCode and also runs in VSCode compatible editors like VSCodium and Code Server. All notes are in plaintext markdown with frontmatter to store optional metadata at the top of the file.

Creating and finding files works in seconds and work through the same interface. If a note doesn't exist, Dendron creates it. This interface is called lookup and it is used to quickly navigate note hierarchies.

Dendron helps with organizing notes using note hierarchies that are represented by dot delimited filenames. For example, foo.bar.baz would be represented in dendron as

.
└── foo
    └── bar
        └── baz

Schemas, Markdown, and All the Links

Dendron gives you schemas, optional YAML that you can associate with each hierarchy which describes their shape and allows Dendron to autocomplete and enforce your organization.

Dendron has its own flavour of markdown that includes additional functionality that enables, latex, mermaid diagrams, and the ability to include content from other notes.

It also has numerous ways of linking your notes together. There are wikilinks to quickly link to any other note, backlinks to see what notes a given note is linked to, hierarchical links to find the parent and children of any note and relative links to go to a specific part of any document.

Publishing, Vaults, and Pods

Dendron comes with built-in publishing - you can compile your notes to static HTML and publish them anywhere. Dendron published sites have been deployed on GitHub pages, S3, Azure, Vercel, Netlify, and more. You have fine-grained control of what gets published and Dendron takes care of the details - any links to private notes from public notes are automatically overwritten with a custom 403 page during the built stage.

Dendron employs a vault-based model for storing notes where a vault is a logical collection of notes, typically backed by git. You can mix and match vaults in a workspace and store them in different places (eg. personal notes on dropbox but company notes locally on the computer). Dendron gives you one unified interface to reference all your notes across all vaults. These vaults can be imported natively in Dendron, either by a relative path or a remote git URL.

Lastly, Dendron has a pod system to help you import/export your notes from Dendron to any other tool and format. We have a JSON pod to export notes and metadata to JSON so you can index it to elasticsearch or create custom visualizations. We have a markdown pod to convert Dendron markdown to regular markdown so that Dendron is interoperable with any tool that accepts markdown.

Today

To date, Dendron has been downloaded over 20 thousand times and powers everything from personal journals to team-based knowledge bases. We ship features weekly and has an active Discord community around note-taking that exchange hundreds of messages a day. My goal is to grow Dendron to be the best note-taking tool for developers, and in time, everyone.

"We are overwhelmed with information and we don't have the tools to properly index and filter through it. [The development of these tools, which] will give society access to and command over the inherited knowledge of the ages [should] be the first objective of our scientist" - Vannevar Bush, 1945

The north star of this project is to achieve Vannevar Bush's original vision - to build a tool of thought that can give humanity "access to and command over the inherited knowledge of the ages".

If you are reading this, you too, are now part of the journey. Let's take back control of our information and use it to build something better, together!

Dendron

Kevin Lin — Fri, 26 Feb 2021 02:47:21 +0000

This contains the public notes for Dendron

Dendron - A Hierarchical Tool for Thought

Kevin Lin — Sun, 01 Nov 2020 17:51:49 +0000

Dendron is a note-taking tool I've been thinking about building for much of the last decade.

All note taking tools help you put notes in, but after a point, they all make it difficult to get your notes back out. Dendron helps you find your notes no matter how many notes you have and works better the more notes you have.

Dendron works by taking a hierarchal first approach to note taking. It provides users with flexible hierarchies that can be used to create, manage, and reference any amount of notes.

Dendron starts with the foundation of flexible hierarchies and builds on top of this foundation with other constructs such as tags, backlinks, and note references (a means to embed notes within other notes). This is so to arrive at a usable centers between purely networked notes (which are often too flexible) and purely hierarchal notes (which are often too rigid).

You can read more about our methodology and try out our tool by visiting our site.

ps. We officially launched on product hunt today. Would love to hear feedback and comments on our product hunt page!

Dendron - an open source, local first, anti-roam note-taking tool

Kevin Lin — Fri, 18 Sep 2020 15:09:40 +0000

Dendron is meant to be the fastest way for people to create, reference, and collaborate on knowledge. It is based on a hierarchal first approach to note taking.

Hierarchy first means that Dendron helps you effortlessly create, manage, and reference your notes through flexible hierarchies. I call it anti-roam because instead of having every note be everywhere, every note is exactly in one well defined place (which you can change over time).

You can read about our principles here

I use Dendron to manage a corpus of 20k+ markdown notes. When I need to lookup information inside Dendron, I know I can either find it in a few seconds, or if I don't, to know for certain that it is not there. This is an incredibly empowering feeling of control in an age of information overload and it is an ability I want to give to every person in the world.

Dendron – a Roam like, open source, markdown based note taking app built on top of VSCode (dendron.so)

Kevin Lin — Fri, 21 Aug 2020 16:31:52 +0000

Dendron is a knowledge management tool that focuses on hierarchal note taking. It provides the freedom of Roam’s every note exists everywhere philosophy while layering on top flexible hierarchies to keep track of it all.

While Dendron works with knowledge bases of any size, it really shines once you’ve accumulated a few hundred notes. I created it to handle my personal knowledge base of 20k+ markdown notes - Dendron lets me track and find any specific note in it in seconds.

Notes created in dendron can be published using github pages. Dendron's homepage is published from this github repo.

Dendron is currently in preview and under active development. If you are looking for a better way of taking notes, I encourage you to give Dendron a try.

For folks coming from DEV, I'm also offering a 30min onboarding to help get started and setup a workspace that matches your note taking goals :)