I believe strongly that the chosen tools should not “get in the way” of interacting with the system, so when I noticed that several of my Evernote workflows include too much repetitiveness and friction – I looked for ways to reduce that friction and enable me to concentrate on the content and not the meta.
Since I am already a fan of Launchy keyboard launcher, I sought for the ideal integration between Launchy and Evernote – something that would allow me to quickly create template-based notes in Evernote, whatever the active application is, in as frictionless way as possible, while still being flexible and powerful.
I found a couple of ideas, like Brandon’s My Simple Curiosity post on Evernote note templates, and Stephen’s Thought Asylum post on the same subject. These posts were inspiring and helpful, and I wound up developing my own solution, relying on stuff I learned from them.
The result is a collection of scripts and utilities I wrote, that does exactly what I want.
What does it do?
Basically, the main script in the collection takes a couple of command-line arguments that tells it which Evernote-note-template to use, and what values to apply instead of the template parameters.
The resulting note (template + replaced values) is then imported into Evernote (to a predetermined notebook, or to one specified by the command-line arguments), and optionally opened in a separate window for further editing (also depending on command-line arguments).
The Launchy integration is based on a set of “proxy batch scripts” that are indexed by Launchy for quick execution.
Each batch script is simply a proxy to running the main script with a specific set of arguments, leaving only one free argument to be filled with the text typed into Launchy (e.g. the title of the note to be created).
The example depicted in the screenshots above should help clarifying:
- I use Evernote to store my GTD actions lists, using tags for managing the different contexts (
.Actionto denote an action-note,
@Onlinefor actions that require some form of web access, and
2-Nextfor actions that are “next actions”).
@online.batbatch script (which is indexed by Launchy) calls the main script with the
@Onlineaction-context tag, and the typed text as the action title (
2. Research re. ...).
- The main script deduces the when-context tag from the action title (
2-Next), and applies the tag and titles to the
- Then the generated note is imported into Evernote (into the specified notebook), and opened in a separate window (because the
--open-noteflag was specified).
This is the basic flow for action-notes creation, as customized to my GTD system.
With no more than basic programming skills (Python) anyone can customize the behavior to their specific systems!
How powerful is it?
The main script, as described above, supports special syntax in the action-title to override the command-line arguments that are set by the proxy batch script.
Most of the time, when I create a new action-note, it should go into the general actions notebook (
2-Actions), with no reminder – so this is the default behavior.
But sometimes I want to use a different notebook (e.g., project-specific actions should go into their project-specific notebook), or set a reminder on the created note to a specific date and time.
To achieve this, the main script parses the action title, and extracts overriding parameters from the beginning of the title.
The syntax for overriding parameters is
Supported parameters are
project for target notebook overriding, and
tickle for reminder setting.
The script tries to understand date/time in natural language by using parsedatetime Python library (so it’s a dependency).
At the moment, if the specified notebook doesn’t exist, it will be created. I don’t like this behavior, and I plan to change it some time in the future. The plan is to try choosing an existing notebook that “looks like” the specified name.
Update October 2013: I implemented “lazy notebook lookup”. If the notebook specified does not exactly match an existing notebook, the script searches for partial matches instead of creating a new notebook.
First, the script looks for a maximal sub-string match – an existing notebook whose name contains the exact supplied string. If there’s more than one such notebook, then the script selects the notebook with the least unmatched characters surrounding the matched sub-string.
Second, the script looks for a maximal word-overlap match. The supplied string and existing notebook names are split on whitespace and
-, and the notebook with the maximal intersection of words with the supplied string is selected.
The utils package contains more stuff that I didn’t cover here, like using AutoHotkey to automate the process of new project initialization in Evernote.
This is explained in the project README, but basically it is based on a AutoHotkey script that creates an empty project-specific notebook, and the same template-based note-importing process for creating initial project notes.
The rest of the post goes into some details about the implementation, that I found interesting enough to elaborate.
Opening the imported note in separate Evernote window after creation
Mentioned shortly above, specifying the
--open-note flag makes Evernote open the imported note in a separate window – a very useful feature that allows me to immediately type content into the new note (or close it if I want to get back to whatever I was doing before that).
This is much more convenient compared to the alternative way of manually opening the note after creation (open Evernote, find the note, open it…).
Interestingly enough, achieving this is far from easy!
I found his approach excellent for a single use-case, where the template is only plain-text note body, without a title, a reminder, tags, or a specific target notebook. If this is your use-case – then Brandon’s approach is perfect for you.
But I have other use-cases (as described in this post), for which this approach breaks.
My alternative solution is as follows:
- Just before importing the note into Evernote (using
ENScript importNotes) I save the current system time.
- After creating the notes, I execute an Evernote search query (using
ENScript showNotes /q 'query') that shows all notes that were created after the time saved in the previous step (this should give only the note that was just imported).
- Then I execute an AutoHotkey script that activates the main Evernote window, and opens the first note in the resulting query (by simulating
This usually works for me, although some times it opens the note that was highlighted before executing the query. I’m not sure why that happens. This is why I used a long sleep time between the activation of the Evernote window and the keyboard simulation (750ms).
Supporting Unicode characters
I couldn’t get this right.
When trying to create notes with Hebrew text, something breaks miserably along the way.
Further debugging required…
Auto-generating the proxy batch scripts
All of my action-note-creation proxy batch scripts are almost identical, differing only in the action context tag.
This means that if I want to change something in the way the scripts work (e.g., omit the
--open-note flag, or change the default notebook) – I need to modify each script in the same tedious way.
Of course – this was enough for me to automate the process of generating these scripts! 🙂
The basic process of the main script described above is to take a template-file, apply template-parameters, and get a result file. So why not reuse the same process to generate my batch scripts?
If you do modify and customize these tools – I’d love to hear about it (in the comments).
Actually, even if you don’t, but you find it useful – I’d also love to hear (in the comments) 🙂