Roam – Tool for Thinking
roamresearch.com
roamresearch.com
Roam does allow you to export all your data to an org-mode file (the emacs outliner), we're working on other import/export options, and want to get to the place where there is a close to plain text representation of your Roam workspace on your file system that syncs both ways.
We weren't expecting someone to post us to HN yet. This is a case of, if you're not embarrassed on launch, you launched too late. Just want to let y'all know we dont believe in SAAS lockin for a tool for thought, and data portability for the folks who aren't emacs users is coming.
Key claim we have is that knowledge doesn't really fit into the tree structure of a file system (nearly 100% of knowledge management tools follow that structure)
In Roam, you can organize things hierarchically -- using indentation -- but when you link to another page, the paragraph or bullet point where you made that link appears in the "references" for that page.
Pages -- like a page for a person, or a concept -- end up getting a sort of implicit definition from all the other places where you talk about them.
So, a page for Alice or Bob for example has all the tasks that have been assigned to them, and all notes from meetings that involved them.
A page for a concept like [[Paul Graham recommends Clojure]] pulls in all the paragraphs or bullet points where you used the term -- and the bullet points nested below.
As a separate comment, I've had really great success using Zotero for this purpose. I already ingest all the journal articles, book references, etc I read into it using the Zotero browser plugin. You can tag items and (bi-directionally) link related items, and add notes with its inbuilt HTML note system. I just have one folder that contains my notes and link them to each other. You can also attach reading notes to the bibliographic entries themselves and have separate folders for project specific notes. A weakness however is that the links do not appear as hypertext in the body of the note but instead in a pop-up menu.
Several of these tools are converging on a similar design for an "active outliner", joining the power of a wiki with the programmability of a spreadsheet. The killer app will be the first one to get the interaction model right for a generic "information workers" audience.
I've often wished to have a "graph" feature where notes could be linked together, and you could see some kind of cluster, or maybe do queries based on number of edges from something. Stuff like that.
It sounds like this tool would offer something like that. But just the front-page doesn't really show enough to be sure if I would find it useful or not. I'm not going to create an account to spent 5 minutes fooling with something I may wind up not liking and never using again.
If the Roam people are reading this thread, maybe think about adding a screenshot gallery, an interactive demo that doesn't need an account, and/or a demo video showing off the key features.
I would potentially be willing to pay for a notes app, but as others have noted SAAS has some problems. The data portability / vendor lock-in aspect can be solved by supporting export into common formats, but this also functionally precludes offline use. That would be a non-starter for me personally.
- https://github.com/zadam/trilium/wiki/Link-map
- https://github.com/zadam/trilium/wiki/Relation-map
The links between notes are stored as rows in a relational database (SQLite) so if you're not afraid of a little bit of scripting, you can easily query by e.g. number of edges if you want ...
- file-based, so that: * migrated to other tools * edited with robust classic text editors * copied, synched and backed-up with external file tools
This is essential so that persistence of the valuable knowledge stored in the application won't depend exclusively on its (fragile) internal tools, but can be managed as a system-level admin task.
- Tree-based, but with external links, to allow for arbitrary network shapes (the basic "tree" outliner shape can be augmented with links to other parts of the network, without having to copy the whole sub-tree)
- Multi-directional (incoming+outgoing) links (This is hard to see in most outliner note-taking tools, but Roam does it pretty well)
- Easy navigation of parts of the tree through breadcrumbs (allows avoiding the "humongous tree of death" by creating "local navigation" views). Workflowy does this very well.
- Tag-based persistent filters that can be stored as nodes in the tree (i.e. you don't need to search in the search bar for a combination of tags every time you want to recover it). With this, you can create new concepts by storing persistent complex searches as part of the tree.
- Easy to set up, share, and use in multiple devices and OSs (mobile and desktop).
I think there should be a way to export to files/directories, but using files/directories as the primary persistence mechanism is inherently limiting:
- Editing things with classic text editors loses the intent of each edit. Ever seen a git diff look radically different from what your changeset intended? That's because a simple A/B comparison cannot recover the intention of each edit. You lose information here. Like, did the user change the name of function A, or did she define a new function that looks a lot like function A? - Backing up with external tools will work. But syncing will be limited. Because the sync tools don't understand the structure of the document. - How does the tool assign a unique ID to the smallest unit of content (say, a word, or a link, or a paragraph?) - Editing files with a classic text editor will also break real-time collaborative editing.
- the only identifier of a file is the path, once you rename a file, all the links pointing to it are broken
- for incoming links you'd have to scan the rest of the notes for links (which will get slow at some point)
Typical way to mitigate this is to create some index files, name note files with UUIDs instead of their natural names, but this then creates a lot of other problems as well.
You might also find out that the limitations of filesystem (strict tree structure, strict split between directories and files) might not be a best fit for note structure ...
Wikis work that way, where the payload of each page is a flat text sequence with simple markup.
The structure, relations and metadata could then be stored in a serverless database, like Git does in the .git folder. Not perfect, but I think the benefits for personal information outweight the limitations.
That depends on the wiki. The most well known - MediaWiki - uses traditional DB like MySQL or Postgres.
> The structure, relations and metadata could then be stored in a serverless database, like Git does in the .git folder. Not perfect, but I think the benefits for personal information outweight the limitations.
What happens when files and metadata go out of sync? People want to have the data in plaintext for interoperability with other tools so they are going to edit the data outside of the app. And your app does not know files changed so it can't selectively update the indexes/metadata.
Another motivation for flat files is that users want to use standard sync tools like syncthing, dropbox etc. But these metadata and indexes will not work at all in case of write conflicts - dropbox does not know how to merge those serverless database files.
They still persist each page as a self-contained single flat text field, though. For the wiki model, it doesn't matter how it is stored in the hard drive, but that you get atomic nodes of content. If the node is a text file, you get the benefit of accessing such content through the file system and a text editor instead of a DBMS. That's invaluable for accessing content from a collection of multiple devices, operating systems and alternative applications, i.e. the use case for personal information.
> And your app does not know files changed so it can't selectively update the indexes/metadata.
Why would the app not know that files are changed? Any development environment nowadays may check for touched files and re-parses them on the fly, for example for instant preview of web pages.
Modern OS provide APIs to watch file changes (on Linux e.g. it's inotify). However:
1) Does not work when your app is not running. When your app starts up it needs to rescan all files.
2) Does not scale well - watching files is expensive and OS usually have usage limits.
IDEs provide a great example since they need to solve essentially the same problem - when my Intellij starts up it spends a while until it scans all the changed files (to do that it must go through all of them). After that it starts complaining that my inotify OS limit is too low and it can't watch all the files in the project.
All this is fine for lightweight use. But if you're serious with using your knowledge base, you'll run into tens of thousands of items in the course of few years.
I have no clue why this is good. It talks about DAGs as a way to organize research, but there is almost zero information about anything really.
How exactly does this help me?
[1] : http://gingkoapp.com
E.g, a user writes in a note labeled to be about a specific date, that they did yoga.
This now shows up as a log entry on the yoga note (presumably automatically. If not, the whole point is gone)
Zim's UI looks more dated and simpler, but underneath it's extremely powerful.
The UI is utilitarian, simple and efficient. It stores all of its note files as .txt so there's lots of other ways to access the info (e.g. grep).
Zim is extensible with a variety of useful plugins too.
Its simple file structure also allows me to pair it with syncthing [0], and sync all of my computers with each other seamlessly. So I have my own self-syncing document trove and knowledge base without any considerable effort.
Using simple apps and integrating them is much more powerful than it looks, and it's one of the simpler things that I enjoy immensely.
I'm somehow not very comfortable putting my ideas or research into some graph db I don't own.
https://www.r-project.org/conferences/useR-2011/TalkSlides/C...
Can also copy/paste in any html
Would build a special emacs importer if there was strong need -- but emacs export is so powerful you can also just export org-files into a format that Roam accepts already
The app itself seems neat so far. Native and powerful bullet point notes apps are something I'm constantly looking for because I haven't yet found the perfect one. This seems like a good contender (though ultimately I want something self hosted).
Is this completely based on the org mode file format or does it only have an exporter for it?
Roam seems to have a lot of the same concepts.
This video is better https://www.youtube.com/watch?v=hMKy52Intac