From my own work in academics as well as during my work as a developer for reference management applications (refbase, Citavi & Papers) I’ve noticed that many students & researchers are trying to implement their own academic reading & notetaking workflow. On the Mac, this usually means combining apps from at least three categories: PDF highlighting, note taking and reference management. And these are just the basics (there’s also outlining, concept/mind mapping, and the actual writing process, etc). But trying to integrate apps from these three basic categories already means a lot of back & forth or scripting/automation.
My app sits in between these three categories and tries to combine some elements from them: E.g., while highlighting your PDF, the app extracts each highlight annotation as a self-standing plaintext/MultiMarkdown note, and can include bibliographic information from your reference manager.
In each note, the app includes the highlighted text as a quotation, adds page information and (if possible) fetches reference info from your reference manager. You can then add your own title/summary/comments to the note, assign it a color label, tag or rate it, and link it with other notes (all via drag & drop, autocompletion or menu commands / keyboard shortcuts). CriticMarkup support helps to further structure your notes.
One can also open a note in its own window (to review or work with multiple notes simultaneously):
All structural elements get syntax colored and are clickable so you can easily navigate your network of notes. Note connections can be visualized in a network graph (which can also be used for navigation).
Since all your highlight annotations are atomic plaintext notes, you can search and filter them freely (independent from the PDF source they came from), and gather them again in structure/overview notes. Selecting a note will also jump to its quoted text in the PDF. And clicking a highlight annotation in the PDF will select its note.
Keypoints is document-based (a document is a Core Data database containing many plaintext notes). Keypoints parses all notes & reference info into a data model to facilitate many of its features. However, on (auto)save, it will also auto-export all notes to a folder on disk, and I plan to also read from this folder. This helps to avoid lock-in and should enable basic integration with other apps/services. The app is also highly scriptable, and I’d like to develop custom export/sync scripts to facilitate good integration with other scriptable apps such as DEVONthink, Tinderbox, OmniOutliner, Papers, Bookends, or BibDesk/Skim etc.
As originally outlined in this thread, the app is based on these core principles:
Free annotations from the PDF & work with them: PDF annotations only get really useful when they are extracted from the PDF. So my app gets them out of the PDF immediately, and you then interact with the resulting plaintext notes.
Notes are plaintext: This ensures maximum longevity, avoids lock-in, and allows for easy integration with other apps. The plaintext notes also give you a good data exit strategy.
Notes are atomic: One note per thought. This allows you to tag to the bullet point level, and it enables you to freely filter, rearrange and reuse them.
Notes are self-contained: Notes should be as self-contained as possible. I.e., the note’s body text (or its metadata) should contain all relevant information (like its tags, creation date, linking & citation info, related file & annotation info, and its ID). This way, you can do lots of things with your notes but don’t loose anything. All relevant info always travels with the note. E.g., you could transfer your notes somewhere where there’s no file path info, like a database, a single text file, or an app that stores files internally using its own naming scheme. Your notes would still remain intact and can be retrieved again w/o loss.
Notes keep their context: This means one should be able to easily see the context of one’s note. I.e., easily jump to the quoted text in the PDF source, and back again. Also, always keep the reference info in the note. If possible, the reference info will be extracted automatically from your reference manager.
Notes can be inter-linked: Directly linking notes to other notes is crucial since this actually captures your thought trains (tagging does not). Also, by creating a network of semantically rich and linked notes, your note relationships can be visualized. The visualization graph also shows your note’s backlinks, and it can even be used to navigate your notes.
Notes are human- and machine-readable: Both are important. The structured plaintext note is your data format. Having it not only human readable but also machine readable allows to build a data model from it, which in turn allows for all kinds of advanced features.
Notes can be reused in other applications: It’s very important that the app (and your notes) can integrate with other apps, via import/export but also directly via scripting/automation.