Getting Things Done with Semantic Notes

Like many adopters of David Allen’s task-management methodology Getting Things Done (GTD, throughout), I tend to binge and purge. About every season, I sort through the physical and digital accumulations of previous months, try to revive my decomposing files and systems, and reinvigorate the paralyzingly procrastinated commitments of my life.

Each time I resume GTD, I discover new tendencies and habits buried in my workflow. Habits that, when left unaddressed, distract or derail my productive and creative processes. To make matters worse, some of these habits only surface after I’ve implemented systems intended to encourage productivity.

Merlin Mann (@hotdogsladies) and Dan Benjamin (@danbenjamin) discussed this recently on episodes 95-97 of the Back To Work podcast. Once one passes through the “productivity porn” phase of GTD, the enormity of the method’s immersive demands sets in and it can be easy to fall behind. Especially because any failures or procrastinations appear as deeper, self-deprecating revelations about You and The-State-Of-Your-Life. Having said that, this winter, I’m back on — or is it off? — the wagon with an assortment of obsessive-compulsive techniques; this time, I’m more committed than ever to devise methods built for stamina and distance. (The following text is lengthly, so I've set up a direct short URL for this page for your convenience: http://semanot.es/. Note that twitter does not recognize .es URLs without a prepended http://, but should strip that out and activate the link upon publishing.)

A System for Notes

The first obvious change I needed to make was the process by which I take, process, refer to, review, and store notes. I needed something with a long lifespan, that requires little maintenance, and allows for an efficient weekly review. A system I can trust with my low-rent schemes, project-related brainstorms, and moments of epiphany. And, it has to prime those things for future use and next-actions.

Since developing a system I can finally implement (and describe to others), my notes are now much more than an area for scratch reference and messy reminders. Now, my notes are collected as palpable raw materials waiting to be transformed into a project, and I’m able to curate reviewed notes as reference materials and keep them a swipe-tap away.

When I sit down to review, a recently created note is no longer swirling turbidly in a list of random jottings, nor is it pigeon-holed in a dozen radically different work environments. It is simply right there floating above a list of processed reference and active drafts, waiting to be reviewed.

If you are not familiar with (or interested in) GTD, the following techniques will still be usable and effective. However, if this method strikes you at all as something that may work for your daily workflow, I highly recommend reading David Allen’s book, Getting Things Done. Because there has been so much written about GTD, I’ll just point you in the direction of the work of others (see the Appendix) for information about what it is and how to get started.

Note: The casual (but confident) Mac user will not have a problem with any of the technical aspects of this method, as it requires no special skill-sets.

Describing the Problem

1. Mobile notes are difficult to review ...

Most often, notes are messages we write to our future selves; they are rarely urgent — or we’d be acting, instead of writing — and contain something(s) that we intend to reference or review. The emergence of high-powered mobile computing seemed to resolve the problem of walking around with “things I have to brainstorm about or remember” trapped in loops in our heads, but taking notes often can introduce new problems which cannot be solved by the mere ownership of a powerful device alone.

Maybe you don’t have time to write a clear note that will make sense later, so you opt to try to record the whole thing in your head. Maybe deep down you know you may not review it soon enough. Maybe you don’t want to create a new note for a new idea because it may get lost in your other notes, so you just record it within a frequently used note. These habits may have two serious consequences: 1., you no longer record critically important information into your notes in a consistent way (or at all), and 2., you no longer trust your notes as a place all of your active reference lives. If, under those conditions, we tell ourselves “because we use a smartphone” we have notes “covered”, we will be creating a risky (ultimately confounding) eddy of false confidence.

... especially if they are in more than one place.

Having more than one “home” for an idea on your mobile device is the first warning sign that your workflow might be dangerously ignorable. My level of clumsiness — and thus, the likelihood of my falling behind in weekly reviews — corresponds directly to the number of places I put important information. I used different applications for the same type of content (notes) with different outcomes. At worst, my pigeon-holes looked something like this:

  • Personal reference and list-keeping in Evernote (100s of notes)
  • Creative Writing in Byword (Current Projects Only)
  • Someday/Maybe fiction writing in the (discontinued) Pad & Quill (Dozens of bad ideas)
  • Brainstorms about subjects in response to emails as Mail.app drafts (a few rarely review documents)
  • To-do reminders to my Things inbox
  • and on-the-fly scratch notes in Simplenotes (100s of notes)

Maybe you do something now that is more or less similar. If so, I urge you to keep reading — as this method may drastically improve the likelihood that you will act on your mobile notes.

Note that none of these are the production areas for a final piece of content; these are not documents waiting to be emailed, typeset, published online, or presented — they are active notes which require further content, review, and reflection. Despite this, they all live in different places with different sets of processing options. The first step in my Semantic Note technique involves wiping the slate until there is only one home for your idea — just one instinctive tap that brings you from having a noteworthy thought to recording it for review.

2. Mobile Notes ≠ Desk Notes

What we jot down on our mobile devices is almost always qualitatively different from what we generate while working in the Desk* environment: quick lists, clever ideas, personal reminders, addresses, phone numbers, etc. Any note-taking system needs to accommodate for this fact without imposing the Mobile circumstance on the Desk environment:

  • Since the primary workspace can be used to process in a much more efficient manner, what can you do on the mobile end to expedite that process?
  • How can you do this quickly without depending on techniques too cumbersome for Mobile, like curate expansive “active topic” tags?

I capitalize Desk and Mobile to designate metonyms for either working with a keyboard and OS X (Desk) or being away from that work site with an iOS device (Mobile), and I will use these context terms throughout. Please note that by Desk, I mean your primary work environment — whether or not it involves a desk or desktop computer.

Simplenote + Notational Velocity, Bar None.

To handle the gap between Desk and Mobile, we should start with a popular paring: Simplenote and Notational Velocity.

Simplenote is a minimally-featured note-taking app that does one thing really, really well. It stores smallish snippets of Plain Text, and searches them; it will locate the note you need immediately, and with only a few keystrokes. Simplenote has its own free cloud-hosting service which I suggest you do without integrating the popular cloud-storage and data-syncing service Dropbox via Simplenote's premium account. Whether you pay the premium is up to you (as it activates features beyond Dropbox integration), but everything in my Semantic Note method is doable with the free version. Beware: using both Simplenote and Notational Velocity to sync via Dropbox at the same time has known issues. Because this method will use eventually use Dropbox (via Hazel), there is no need to worry that your notes will be lost or unavailable.

Notational Velocity* (NV, throughout) is the amazing Simplenote companion app for OS X. It syncs with and behaves like Simplenote, but contains several features optimized for the Desk environment. Namely, it has a completely mouseless search-based interface that allows you to drill down through your notes on a per-keystroke level. This is exactly what we’ll need for a note workflow that expedites the processing and reference steps in the GTD regimen.

I write everything to be published on the web in Markdown, John Grueber’s (@gruber) readable text-to-HTML syntax. I love this simple and readable form of writing for the web, and “you should too.” I’ve included a couple links about Markdown in the Appendix if you’re unfamiliar. However, if you already use it frequently, I suggest using Brett Terpstra’s (@ttscoff) fork of Notational Velocity called nvAlt, which has lots of useful Markdown functionality.

So What’s The Problem, Exactly?

Ok, so Simplenote + Notational Velocity. It’s already a popular power pairing. But for all the combo solves, if you’re trying to seal up leaks in your GTD workflow, several problems still remain:

  1. What keystrokes will find the note you need?
  2. How do you know which note to add information to?
  3. How do you review an ever-shifting assemblage of lists and snippets?
  4. How do you process new notes you know you’ll still need at your fingertips?
  5. How do you archive a note after you’ve “closed its loop”?

3. The note you need should be instantly available.

We’ve already limited the amount of “searching for the place” by consolidating our options. Let’s apply the same logic to the notes. This begins and ends with the title of the note itself.

Refining Mann’s Q

Merlin Mann suggests a “greatest hits” approach to note search. That is, a rating system which tags a note’s title with graduating degrees of significance or immediacy. He described this method on the Mac Power Users podcast (MPU #23), and elaborated it on his blog:

“[I] end the file name of all my most frequently used or referenced files with a certain number of Qs. Why?

If I type qq, I whittle down to 15 or so greatest hits. If I type qqq, I narrow down to an even more rarefied handful of really important files. And, so on, until qqqqq takes me to exactly one ‘agenda’ file where I throw anything I need to capture or do today, but only have a second to grab.

Why q?

It’s right under my left thumb on the iPhone.

No English word I use contains more than one q
Posted by Merlin on kungfugrippe.com, March 16, 2010

Though I think this is a clever solution, it kind of rubs me the wrong way: it breaks the same guidelines Markdown is principled upon — readability and semanticsQs are a good solution as they are easy to tap, but they aren’t a great solution. Why? Because 1., they are arbitrary non-semantic designations to an important piece of content (the title of the note) and 2., they interfere with the legibility of trans-notational links.

Finally, the Q doesn’t describe the type of content contained in the note, just its importance. This isn’t an issue when you’re grabbing a note on-the-go, so it would be a fine solution if you only used mobile notes. But the blowback is twofold when it’s time to process, review, and archive* the notes at your desk. A lot of notes — with a lot of qs — and nothing to help you understand what or what next. We have to find a way to fill in these features while preserving that quality of “capture or [show what to] do, with only a second to grab” that makes the Merlin’s Q so provocative.

If you use the Q method, see Endnotes for a workaround to this archival problem.

4. Easy, Fast, and Productive?

There’s an old craftsperson’s slogan that goes something like this: “We offer good, fast, and cheap ... only two per customer.” I think this wisdom applies especially to GTD systems – since Mobile and Desk have different sets of circumstances, no single pair of the craftsperson’s three will suit both contexts at the same time. But this restriction could work to our advantage; we can optimize according to the unique conditions of each context, then find the best way to toggle between those modes.

Rules get broken, limitations make you stronger.

Semantic Notes should not be a set of complex rules that you must recall every time you want to take a note, since mobile circumstances rarely permit high specificity. A mobile Semantic Note should thus not require any sorting or tagging at the time of creation, but still be differentiated from the reviewed and specified notes while you refer to notes on your mobile device and clearly unprocessed when you’re at your work environment to process and review.

The Importance of Semantics

“Semantics” was one of those Web 2.0 buzzwords for awhile so many in web-related fields are familiar with it. However, it’s an important word to systems in general, so it's important to understand what it means in a broader sense. It’s a linguistic term designating one of three recognized root aspects of a language — the other two being syntax and, often, grammar. In short, semantics describes what a word or phrase signifies logically to a larger, self-referential system of signs and symbols.

With the rise of support for HTML5, front-end web developers have embraced semantic HTML because it allows styling and placement to happen elsewhere, and subsequently implementing new features won’t require editing existing content. Any note system that contains both unprocessed and processed notes should also utilize semantics in this way so that different types of content can be clearly recognized, but made functional by external operations.

Semantic Notes

1. Permissible to forget,
2. Impossible to betray,
3. Simple to process and review.

Ditch String Tags.

Let’s right away throw traditional string tagging out the window.* Formally adding content-related strings as “tags” for a note is, in my opinion, a recipe for a GTD breakdown. If you are capable of using (and reviewing) tags like “recipes”, “roadtrip”, “quotes”, and “read” on a regular basis, then hat’s off to you. But I’ve never found this solution to be 1., quick on the draw, and 2., uniform enough to recall and follow without error. Next, if these tags contain important pieces of information like an associated larger project or area of responsibility, you’ll completely lose that information when you export the note to send it to someone else, or archive it outside of your note cloud.

In my view, remembering to use string tags in a mobile environment is just distracting, and when I’m at my computer they’re practically useless — perhaps most critically, they have case-sensitivity and duplicate/overlap issues which make handling massive and immersive systems like GTD incomprehensible.

This is not to be confused with the four GTD “context, energy, time, and priority” tag types (to which I add a fifth, budget). I use these tags all of the time in my project management software to specify situations such as: @errands, @computer, @15min, @exhausted, @high-priority, @$50, and @house. These tags are designed to refine action steps based on your current resources, not describe what the associated reminder will contain. This is a non-semantic, procedure-based functionality — we should let it remain one of the external operations that benefit from a Semantic Note method by passing any action-ready notes directly (following review) to a task management system like OmniFocus or Things.

Markdown Principles for Meta Notes.

Notational Velocity has a powerful wiki-style note-to-note linking syntax, so a good Semantic Notes system should take full advantage of this. By wrapping the title of any note in [[double-brackets]], NV will automatically activate a link to that note. Simplenote doesn’t have this feature, therefore it is necessary that the title of every note degrade readably a la Markdown — likewise, if a note contains a note-link, it should be clear what that note contained based on its title.

This is why Merlin’s Q can’t cover all our bases. Inter-note links will fill your document with strange, forensic Q artifacts, rendering it unreadable to anyone else — perhaps you need to quickly email a note to someone, or your best friend is reading your “what to do in the event of an epileptic seizure” note whilst you experience one. Whenever you need it to work, you will understand the importance of such a standard immediately.

Further, note titles should be content in themselves. If you choose to link to it within a note, it should represent real content (even if it will only be read by you), and not be an unreadable signpost to content elsewhere. That means we need a method to describe the kind of content — I’ll call a kind of content an “element” — contained within a note without distorting the title’s legibility.

Semantic Note Elements.

Element, in the Semantic Note sense, corresponds to its meaning in much the same way semantic HTML uses the term; a note element is simply a note described by a semantic tag existing in its title. Semantic Notes append element tags via character glyphs at the beginning of notes, which I’ll explain in greater detail soon. For now I’ll give two reasons for adding content-describing glyphs before titles: 1., we want the link title to function as content when linked in NV, and 2., we want the elements to be grouped together when sorted alphabetically.

Mobile-first

This responsive-design mantra was useful in devising a system that worked for notes — start from the mobile user experience and then move outwards. What are the mobile circumstances?

  • Limited glyphs via text input.
  • “Cheap” and “Fast” are more important than “Good”.
  • All new notes are, by virtue of context, “scratch notes”.
  • Reference material is still needed for quick glances.

The system should take advantage of these limitations, rather than provide simple “workarounds”. What kind of content do we use our mobile devices to create and retrieve? Your list may differ from mine, but the principles are the same. Here is the list of elements (See Endnotes for definitions) that I need to create or rapidly access in a mobile environment:

  • Unordered Lists
  • Checklists
  • Help Files
  • Plain text to process later.
I also use an at symbol (@) to flag a note as an idea for a tweet that is waiting for the right time.

As you can see, there are really only three specific elements I need to create on my mobile device. Remember that “plain text to process” will catch anything that needs to be processed later, during a review at your work station. I need to find four symbols which will be quick to access on the mobile keyboard, including one that operates as an item in my “inbox” (behaving just as it would if I wrote it down and put it in my physical inbox). I have chosen the following element tags:

  • - (hyphen) for unordered lists
  • * (asterisk) for checklists
  • ? (question mark) for help files
  • (word space) for unprocessed scratch notes

When I create a new note with my phone, I will be able to easily create one of these four elements simply by beginning the note title with the corresponding glyph, followed by a space. This means that a double space indicates an unprocessed note, so adding a new note to your “inbox” is as simple as a double-tap on the iOS keyboard’s spacebar. This, as we will see, proves incredibly useful when I process my notes.

More Than Just Mobile.

My desk environment permits a lot more review and process power, so I allow myself a much larger range of elements when I’m at my computer. This list should comprise everything available to mobile use, and additionally include any other element type I may need:

  • Unordered Lists
  • Checklists
  • Help Files
  • Plain text to process later
  • Ideas for Tweets
  • Paragraph/Snippets
  • Code
  • Text not to be edited
  • Subjects
  • Outlines

I’ve deliberately chosen symbols that are difficult or impossible to type with the iOS keyboard for these Desk elements, as such notes will communicate to me that they contain information I’ve already inspected for next-actions or other critical information that belongs elsewhere. They’re just as searchable, but I’m not tempted to cheat or workaround the system by circumventing the inbox and dropping a note directly into my reference/project materials area. Anyone who has struggled with GTD will probably identify this habit as one of the hardest to break (this is the problem which originally inspired me to implement Semantic Notes). These glyphs represent my personal list of element types listed above (see Endnotes at the bottom for a definition of terms):

  • - (hyphen) for unordered lists
  • * (asterisk) for checklists
  • ? (question mark) for help files
  • (word space) for unprocessed scratch notes
  • @ (at symbol) for tweets on deck
  • (pilcrow) for paragraphs and snippet strings
  • ¢ (cent sign) for code
  • § (section mark) for final work, or text not to be edited
  • # (octothorp) for subjects to remember, inversely graduated for importance
  • ø (slashed o) for outlines

How many elements you require is a non-issue (aim for brevity), as adding and subtracting tags is simple; if you need a reminder, store these lists as help files in your note system — ? SN Element Tags, or individually as ? Mobile SN Tags and ? Desk SN Tags.

Implementation

Process to Zero. Often.

If you want to begin using Semantic Notes, the first thing to do — right now — is add a next-action item “process existing notes for Semantic Notes” to your to-do system’s inbox. This might by scary, but if you’ve started GTD before, you’ll know that tasks such as this don’t necessarily take hours upon hours. But, even when they do, the investment of time always pays off. Remember to archive (see the section titled Archiving near the end of this essay) notes you no longer need readily available.

Processing during Review

Semantic Notes are optimized for daily and weekly reviews. Simply instruct NV to sort notes alphabetically by title (by clicking title in the list-details sorter directly beneath the search field), and there floating at the top will be a list of all of the unprocessed notes (read: notes with titles beginning with two word spaces) you’ve generated on your phone, or haphazardly at your desk. The days of sorting by date-modified or date-added are now behind you. Celebrate with a dance or a facial tic, and roll up your sleeves.

To process, simply open each note, edit it if necessary, and process it just as you would an index card in your physical inbox using GTD. Afterwards, if any content needs to be kept on hand, tag it as the appropriate element using the corresponding glyph (hit Apple + R to rename an active note). Remember to ask yourself if this note needs to be available as such in the first place — could you permanently archive it, instead? If, while processing, you find that all of the note’s content has been moved to other systems (contact information, appointments to remember, to-do list, movies to queue, etc.) just delete the note. This may seem counter-intuitive — Simplenote + NV can handle 1000s of tiny notes without so much as a wheeze — but the more needless and duplicated stuff you purge from your note system, the more you will learn to trust that it contains important and useful information.

If you want to return a note to your Semantic Notes Inbox, simply replace the glyph symbol with a word space. During your weekly review, it will reappear at the top with your raw notes.

If you forgot to tag a mobile note with two preceding word spaces, all is not lost. Because Semantic Notes adds glyph tags only to processed notes (or element types which you’ve decided to review regularly) you can scan your note list for any non-tagged note title in a matter of seconds. This failsafe is one reason why we started with the mobile format and intentionally restricted the creation of note types that may otherwise get lost in the fold.

One final thought regarding processing: since you’ll be working this process into your daily or weekly review, remember to place it towards the beginning of your routine. If you happen to refer to notes during any part of your review, you will trust that the entire catalog of notes is up-to-date and does not contain any time-sensitive next-action items. Personally, I review many lists in my notes every week — among them are: * Weekly Review, -  Recurring Web Service Subscriptions, and - Software Wishlist — some of them I glance at just to make sure they’re up-to-date, and some of them I just couldn’t do my review without. Either way, knowing that there could be tagged elements that I haven’t reviewed since creating them in the field would seriously sap my motivation to check my notes regularly.

Semantic Interface

Once your notes are tagged elements in Simplenote + NV, you can easily organize them by element type by opting to sort notes alphabetically in NV. In the sort details directly beneath the search field, you can change the sort order to alphabetical by clicking name. Not only will these notes be grouped by element type, but they’ll also be organized alphabetically within that grouping. Cool. This makes reviewing your notes so simple.

Further, you can simply type the glyph corresponding to a tag to filter all of the element types to the top. Typing the glyph followed by a space and then more content will search all documents which contain both the glyph and the subsequent search content, so you don’t need to know the title of the note you’re searching for to locate it. For example, to find the outline for the essay you’re planning to write about French Libertarian Communism, simply search ø comm. This will filter out all of the other notes with text containing the string “comm”, returning just your outline.

Outlines

I hope by now I’ve made my case for Semantic Notes. Dare I say, “it gets better”? Outlines. Making outlines with Semantic Notes is choice.

Because we can embed note-titles as links within other notes, and those links will themselves be readable content, making an outline is now as simple as including a list of titles (linked with the [[double-bracket]] syntax) within a note titled ø Outline-Name. Within this text file, any linked notes will clearly demonstrate not only the content of the linked-note (vis-a-vis a processed and clear title), but also the semantic imperative contained within the title itself. For example, a list note will clearly demonstrate a set of things to briefly cover, a paragraph/snippet note will convey a lengthly text to elaborate, and, according to my glyph set, a § note can represent a block quote. Using clipboard shortcuts, the outline can be quickly arranged and edited according to the most logical narrative sequence.

I start to appreciate all my semantic markup when I start to build an outline. Consider this example: I'm making an outline and for a certain section I feel like I need to grab one of my help notes — I simply type two open brackets [[ (to activate an inter-note link) followed by a ? to let my system know I'm looking for a help file. It returns a list of all my help files, and waits patiently for me to browse it and select, or continue typing to narrow my options:

question-mark-only.jpg
question-mark-project-abbr.jpg

The radical change made to taking and processing notes suddenly becomes a very real project-preparation tool for quickly composing outline drafts.

Additionally, you can create prompts for new notes using the exact same note-link syntax. For example, linking to a note titled ¶ Semantic Interfacing that doesn’t yet exist in your note cloud will populate the search field in NV. You can then create a new note simply by pressing enter. Once you do this a few times, you will start to brainstorm about text in new and radically more efficient ways, drafting rough outlines complete with a collection of existing and yet-to-be-written material in a matter of minutes.

Here is this essay as first outlined with this method (time taken, 4 minutes):

outline.jpg

As should be clear, this is one iteration of the outline I had for this text. Everything about this outline is readable, that’s the most important thing. If I pasted this whole note into an email, the recipient would easily be able to read and understand what I have in mind for the final essay. Likewise, if I were to export this as a .txt file, the archived version would also degrade gracefully after the links break. Some of these weren’t notes at the time — mostly the # Subject elements — and creating new notes with those titles after finishing this draft of my outline helped me reflect on what kind of new content I should be brainstorming about. All in all, this outline took me about four minutes. I had already been taking tiny notes over the previous weeks and processing them weekly into lists, strings, and other elements, so gathering and arranging them into a logical sequence is really all I had to do.

Archiving

I only keep about 50-100 notes in circulation at a time. When I’m done with a note, I archive it. If you find that you need a substantially larger number of notes (a swipe and a tap away at all times) you should permit yourself to have them. Certainly, Semantic Notes can handle it. However, if you merely decide you need thousands of notes, without really considering the ramifications thereof, or GTD method, or to your ability to review them ... well, to be frank: you may unknowingly be subtracting years from the end of your life. Part of the power of GTD is its ability to decide when something is no longer a project material and simply needs to be filed as reference. The fact that computers are able to handle our seemingly endless supply of “file cabinet filler” doesn’t mean they should, it’s up to us whether or not we need everything we’ve ever noted at our fingertips, always.

As detailed earlier in the processing section, if you can review and maintain hundreds or even thousands of notes, there is no reason you shouldn’t be able to identify those notes which no longer belong to open loops and active projects, or are required more generally for on-hand reference. A well-seasoned and principled GTD practitioner should, in theory, be able to identify and archive at least five or six inactive notes out of a list of hundreds once a week during their review. If they cannot do this, this proves one of several possible truths:

  1. they spent the week doing nothing;
  2. they are writing temporary notes elsewhere, or not at all; or,
  3. they don’t have the energy, time, or ability to review hundreds of notes.

Whether you store 50, 500, or 1500 notes in your system, I believe this Semantic Note methodology should scale up effectively, and enable you to handle (and curate) any size pool of notes with grace and command. Archiving is the last step of Semantic Notes, and is just as important as the first.

A good archiving system will build confidence in your notes, too. Every step of review/process will prepare your note for this final archival resting place, so you can tap notes on your phone when the moment of inspiration strikes and know that one day your idea will be fully realized, associated with other relevant project materials, and filed away in local and remote backup. The knowledge that your note will eventually be archived for safe keeping will free you to spend a moment of time processing your notes with clarity and enthusiasm. Don’t underestimate the importance of understanding how your ideas will transform from raw stuff into refined materials ready to become part of a greater whole — notes aren’t incidental thoughts that you could just as easily discard, they are the first forms of every project in your life (large and small) and should be treated like any other project material.

Packaging notes for easy reactivation is also a snap with this method. Below, you’ll learn how to sift through an out-of-pool note archive in the cloud for notes relevant to an old project, and re-engage them in seconds.

Steps:

1. Start Using Hazel.

Hazel is a utility for OS X which works silently in the background to organize your files (see Appendix to get started).

2. Establish a Simple Hazel Rule.

Watch Inbox folder for incoming .txt files, append today’s date in parentheses to the end of the filename — (yyyy/mm/dd) — and move it a folder* called Note Archive somewhere in your Dropbox folder.

I have a second note archive for “someday/maybe” notes that I’ve decided not to act on or use in any way, but may want to grab for a project I’m not planning to start in the foreseeable future. I send archived notes to this folder using exactly the same method, except with an additional Hazel rule which treats .txt files containing a tilde (~) differently.

3. Export Note in Notational Velocity

  • File > Export (Apple + E) selected note.
  • Save As “Filename”, optionally adding a project- and/or client- name in [brackets] to the end.
  • File Format: Plain Text
  • Where: an Inbox folder*.

If you’re using GTD and you don’t have a computer wide inbox in your file directory, start one now.

When To Archive

Importing Archived Notes with Primitive Versioning

This method produces a text-based “versioning” procedure which provides a failsafe, should you ever export notes with the same title, or the same note twice. It won’t overwrite an existing archived document or create a duplicate file because dates at the end of the filename flag each iteration as a distinct file. This isn’t just a failsafe for dupe protection – imagine importing these notes at a later date.

Let’s say you have a note called § Lecture Opening. Every time you do a lecture, you export it (quickly with Apple + E) and erase its contents. Every iteration will appear in your archives. The first one being, perhaps, § Lecture Opening (2011/2/28).txt The next one might be called § Lecture Opening (2011/10/31).txt. Imagine you repeat this process a dozen more times. Remember that you haven’t changed the title of the note in Notational Velocity, so the link to your § Lecture Opening note still hasn’t changed in your ø Lecture outline. Then, a year later, you want to expand the lecture into a book, and use the lecture openings in the draft of its introduction. Simply Spotlight search for ø Lecture Opening in Finder and import all these files back into Notational Velocity. Each iteration of your § Lecture Opening will be dated in the title and represented by a different note. These multiple § elements will still group when sorted alphabetically, and they will additionally be organized chronologically since everything before the date will be exactly the same. Moreover, you still haven’t interfered with the original note named § Lecture Opening, which may still exist in its most recent pre-export version. And, most importantly, you haven’t created any conflicts between duplicate filenames when you bring something out of your archive and back into play.

Because your Note Archive should be in your Dropbox folder, anything in it should still be accessible via mobile device or remote browser login – and since they are .txt files you can read them from pretty much any device or operating system.

Congratulations, you are now one step closer to hitting bottom.

Implement your version of this system, and the area of your attention devoted to time management will permit your creative self to run wild with brainstorms, mental sweeps, hare-brained schemes, and someday/maybe ideas whenever the lightbulb turns on. Because you now know for certain that your notes will be processed from raw data into useful active notes, you won’t have to depend on a complicated tagging or titling methodology while you’re waiting in traffic or at a crowded party, or whatever.

When it is time to turn your notes into a writer’s draft or set of next-actions, you’ll have a processed list of useful stuff waiting, triggering, prompting. You can embed those notes in subsequent notes, pass the text on to someone else, and your note links will be readable to them and dynamic to you. When you’re completely done with a collection of information, you can archive it in a way that makes retrieving it at a later date simple and helpful. And finally, with little more than a few Hazel rules, you will have migrated a backup of your Simplenote data to local storage and Dropbox cloud storage without the “crazymaking” of reiterated or duplicated files caught in sync loops.

Start jotting, and don’t stop!

Acknowledgements & Follow Up

I’d like to thank Merlin for inspiring this latest GTD pageantry, and Scott for the convincing argument to write this blog; “being a total maniac will help differentiate you.” Oh yeah, thanks to David Allen for his supreme diligence.

Discussion regarding this method can be found on twitter by searching for #SemanticNotes, and this page can be quickly referred to with the URL semanot.es. If you have any questions or comments, you can reach me via twitter @abolishme or (if you insist) my email abolish.me. I realize this is a huge text, but it all had to be said in the same place. Follow-up articles are already being outlined. If I told you this was protected under copyright, would it even matter?

If you read all 6,910 words of this, consider throwing in a dollar or two towards a stupid-clacky Das Keyboard:

Endnotes

Definition of Terms

* Checklists are lists of tasks or reminders to look over again and again. I use checklists for my routines and reviews, “double-check” lists when I leave town, and mental-sweep triggers. But they could also be chores, hardware setup sequences, or musicians’ set lists.

? Help Files are typically files I use for reference and important project material that I may need quick access to, but otherwise unlikely to be used directly as content themselves. I use help files to store travel itinerary for myself and loved ones, to document health and car insurance information, and to remember the name and price of my favorite menu items at various restaurants. These could also be emergency response details, the tuning sequence for an orchestral instrument, or the modular scales involved in a design project.

# Subjects are topics I’d like to consider generally. Because the # (octothorp) is also the marker for headings in Markdown, I use it for things that may one day become the heading for a section of text. The number of #s preceding the title indicate the sub-ordinance one thought might have to others. This often corresponds to a scaling down of David Allen’s metaphor of elevation for I mark all the big ideas in my head with a single #, then when I think of concepts generally of interest, I mark them with two #s, and so on. I only ever have about six or seven big concepts on my mind at a time, so if ever want to review them I simply enter a single # into the search field and see the big ideas first, followed by all the smaller ones vertically.

Archiving Q notes

If the Q method, or something like it, works too well for you, and you won’t adopt a purely semantic method, you can still archive your notes according to these guidelines by instructing Hazel to remove each of your q sets from incoming notes: it will have to search for [qq], [qqq], [qqqq], and [qqqqq] in any filename and remove it before processing the note further, and shipping it to your archive.

TextExpander Prompt

Brandon Pittman suggested using TextExpander snippet to display a prompt containing your currently available element types:

%fillpopup:name=Type of Note: :-:*:default=?:@:¢:¶:§:#:ø% %filltext:name=Note Title:width=30%

Using this technique could be a useful way to handle a long list of post-review element glyphs.

Appendix – GTD Methodologies & Tools

Getting Things Done

Email

Markdown

Hazel

I use Hazel for a plethora of GTD-related tasks on my computer; whether it’s making sure every “unreviewed” file on my computer first goes to my “inbox”, or tagging active project folders I haven’t modified in the last two weeks — Hazel always comes through. At some point in the future, I plan to detail how I do all of this, but in the meantime, here are some links to get you started with Semantic Note archives: