# Category Archives: emacs

## Windows: Pipe output to your clipboard, or how I’ve been using NodeJS and Org Mode together

It’s not easy being on Windows instead of one of the more scriptable operating systems out there, but I stay on it because I like the drawing programs. Cygwin and Vagrant fill enough gaps to keep me mostly sane. (Although maybe I should work up the courage to dual-boot Windows 8.1 and a Linux distribution, and then get my ScanSnap working.)

Anyway, I’m making do. Thanks to Node and the abundance of libraries available through NPM, Javascript is shaping up to be a surprisingly useful scripting language.

After I used the Flickr API library for Javascript to cross-reference my Flickr archive with my blog posts, I looked around for other things I could do with it. photoSync occasionally didn’t upload new pictures I added to its folders (or at least, not as quickly as I wanted). I wanted to replace photoSync with my own script that would:

• add tags based on the filename,
• add the photo to my Sketchbook photoset,
• move the photo to the “To blog” folder, and
• make it easy for me to refer to the Flickr image in my blog post or index.

The flickr-with-uploads library made it easy to upload images and retrieve information, although the format was slightly different from the Flickr API library I used previously. (In retrospect, I should’ve checked the Flickr API documentation first – there’s an example upload request right on the main page. Oh well! Maybe I’ll change it if I feel like rewriting it.)

I searched my existing photos to see if a photo with that title already existed. If it did, I displayed an Org-style list item with a link. If it didn’t exist, I uploaded it, set the tags, added the item to the photo set, and moved it to the folder. Then I displayed an Org-style link, but using a plus character instead of a minus character, taking advantage of the fact that both + and – can be used for lists in Org.

While using console.log(...) to display these links in the terminal allowed me to mark and copy the link, I wanted to go one step further. Could I send the links directly to Emacs? I looked into getting org-protocol to work, but I was having problems figuring this out. (I solved those problems; details later in this post.)

What were some other ways I could get the information into Emacs aside from copying and pasting from the terminal window? Maybe I could put text directly into the clipboard. The node-clipboard package didn’t build for me and I couldn’t get node-copy-paste to work either,about the node-copy-paste README told me about the existence of the clip command-line utility, which worked for me.

On Windows, clip allows you to pipe the output of commands into your clipboard. (There are similar programs for Linux or Mac OS X.) In Node, you can start a child process and communicate with it through pipes.

I got a little lost trying to figure out how to turn a string into a streamable object that I could set as the new standard input for the clip process I was going to spawn, but the solution turned out to be much simpler than that. Just write(...) to the appropriate stream, and call end() when you’re done.

Here’s the relevant bit of code that takes my result array and puts it into my clipboard:

var child = cp.spawn(‘clip’); child.stdin.write(result.join(“\n”)); child.stdin.end();

Of course, to get to that point, I had to revise my script. Instead of letting all the callbacks finish whenever they wanted, I needed to be able to run some code after everything was done. I was a little familiar with the async library, so I used that. I copied the output to the clipboard instead of displaying it so that I could call it easily using ! (dired-do-shell-command) and get the output in my clipboard for easy yanking elsewhere, although I could probably change my batch file to pipe the result to clip and just separate the stderr stuff. Hmm. Anyway, here it is!

See this on Github

/**
* Upload the file to my Flickr sketchbook and then move it to
* Dropbox/Inbox/To blog. Save the Org Mode links in the clipboard. -
*/

var async = require('async');
var cp = require('child_process');
var fs = require('fs');
var glob = require('glob');
var path = require('path');
var secret = require("./secret");
var SKETCHBOOK_PHOTOSET_ID = '72157641017632565';
var BLOG_INBOX_DIRECTORY = 'c:\\sacha\\dropbox\\inbox\\to blog\\';
var api = flickr(secret.flickrOptions.api_key,
secret.flickrOptions.secret,
secret.flickrOptions.access_token,
secret.flickrOptions.access_token_secret);
var result = [];

function getTags(filename) {
var tags = [];
var match;
var re = new RegExp('#([^ ]+)', 'g');
while ((match = re.exec(filename)) !== null) {
tags.push(match[1]);
}
return tags.join(' ');
}
// assert(getTags("foo #bar #baz qux") == "bar baz");

function checkIfPhotoExists(filename, doesNotExist, existsFunction, done) {
var base = path.basename(filename).replace(/.png$/, ''); api({method: 'flickr.photos.search', user_id: secret.flickrOptions.user_id, text: base}, function(err, response) { var found = undefined; if (response && response.photos[0].photo) { for (var i = 0; i < response.photos[0].photo.length; i++) { if (response.photos[0].photo && response.photos[0].photo[i]['$'].title == base) {
found = i; break;
}
}
}
if (found !== undefined) {
existsFunction(response.photos[0].photo[found], done);
} else {
doesNotExist(filename, done);
}
});
}

function formatExistingPhotoAsOrg(photo, done) {
var title = photo['$'].title; var url = 'https://www.flickr.com/photos/' + photo['$'].owner
+ '/' + photo['$'].id; result.push('- [[' + url + '][' + title + ']]'); done(); } function formatAsOrg(response) { var title = response.photo[0].title[0]; var url = response.photo[0].urls[0].url[0]['_']; result.push('+ [[' + url + '][' + title + ']]'); } function uploadImage(filename, done) { api({ method: 'upload', title: path.basename(filename.replace(/.png$/, '')),
is_public: 1,
hidden: 1,
safety_level: 1,
tags: getTags(filename.replace(/.png$/, '')) }, function(err, response) { if (err) { console.log('Could not upload photo: ', err); done(); } else { var newPhoto = response.photoid[0]; async.parallel( [ function(done) { api({method: 'flickr.photos.getInfo', photo_id: newPhoto}, function(err, response) { if (response) { formatAsOrg(response); } done(); }); }, function(done) { api({method: 'flickr.photosets.addPhoto', photoset_id: SKETCHBOOK_PHOTOSET_ID, photo_id: newPhoto}, function(err, response) { if (!err) { moveFileToBlogInbox(filename, done); } else { console.log('Could not add ' + filename + ' to Sketchbook'); done(); } }); }], function() { done(); }); } }); } function moveFileToBlogInbox(filename, done) { fs.rename(filename, BLOG_INBOX_DIRECTORY + path.basename(filename), function(err) { if (err) { console.log(err); } done(); }); } var arguments = process.argv.slice(2); async.each(arguments, function(item, done) { if (item.match('\\*')) { glob.glob(item, function(err, files) { if (!files) return; async.each(files, function(file, done) { checkIfPhotoExists(file, uploadImage, formatExistingPhotoAsOrg, done); }, function() { done(); }); }); } else { checkIfPhotoExists(item, uploadImage, formatExistingPhotoAsOrg, done); } }, function(err) { console.log(result.join("\n")); var child = cp.spawn('clip'); child.stdin.write(result.join("\n")); child.stdin.end(); });  Wheeee! Hooray for automation. I made a Windows batch script like so: up.bat node g:\code\node\flickr-upload.js %*  and away I went. Not only did I have a handy way to process images from the command line, I could also mark the files in Emacs Dired with m, then type ! to execute my up command on the selected images. Mwahaha! Anyway, I thought I’d write it up in case other people were curious about using Node to code little utilities, filling the clipboard in Windows, or getting data back into Emacs (sometimes the clipboard is enough). Back to org-protocol, since I was curious about it. With (require 'org-protocol) (server-start), emacsclient org-protocol://store-link:/foo/bar worked when I entered it at the command prompt. I was having a hard time getting it to work under Node, but eventually I figured out that: • I needed to pass -n as one of the arguments to emacsclient so that it would return right away. • The : after store-link is important! I was passing org-protocol://store-link/foo/bar and wondering why it opened up a file called bar. org-protocol://store-link:/foo/bar was what I needed. I only just figured out that last bit while writing this post. Here’s a small demonstration program: var cp = require('child_process'); var child = cp.execFile('emacsclient', ['-n', 'org-protocol://store-link:/foo/bar']);  Yay! 2015-01-13 Using Node as a scripting tool – index card #javascript #nodejs #coding #scripting ## Org Mode: Reusing the date from file-datetree-prompt Update 2015-02-17: Or you can just use %t in your org-capture-templates, as Seth Mason points out in the comments… =) How can you get Org Mode to create and schedule entries within a year-month-day outline structure? You can define an org-capture-templates with the keyword file+datetree+prompt. This lets you specify a date for your entry, and Org will create the entry in a hierarchy organized by year, month, and day. If you’d like to display the entry in your agenda, you’ll also need an active timestamp of the form <yyyy-mm-dd>. Fortunately, you can reuse the date you specified at the initial prompt to create the datetree entry. Looking at org-capture.el will show you that the org-capture function refers to the org-read-date-final-answer, which is set to whatever string you entered at the date prompt. For example, if you entered 18, then org-read-date-final-answer will be set to 18. You can use org-read-date to convert this back to a yyyy-mm-dd-style date. How do you use this in org-capture-templates? You can use the %(...) syntax for calling an Emacs Lisp expression, like so: (setq org-capture-templates '( ;; other entries go here ("s" "Journal entry with date, scheduled" entry (file+datetree+prompt "~/personal/journal.org") "* %^{Title}\n<%(org-read-date nil nil org-read-date-final-answer)>\n%i\n%?\n")))  Here’s sample output from that capture template: * 2015 ** 2015-12 December *** 2015-12-31 Thursday **** End of the year party! <2015-12-31>  Thanks to Sean Miller for the nudge to think about this! ## Continuous integration and code coverage for Emacs packages with Travis and Coveralls Do you maintain an Emacs package hosted on Github? Would you like to get those confidence-building, bragging-rights-granting, other-developers-inspiring build: passing and coverage: 100% badges into your README file? It turns out that this is pretty easy with ERT, Cask, Travis CI, undercover.el, and Coveralls.io. 1. Log on to Travis and enable continuous integration for your repository. 2. Log on to Coveralls.io and enable coverage testing for your repository. 3. Set up a git branch, since you’ll probably be making lots of small commits while you smooth out the testing workflow. 4. Define your tests with ERT. See https://github.com/abo-abo/tiny/blob/master/tiny-test.el for an example. For undercover support, you’ll want to include something like: (when (require 'undercover nil t) (undercover "tiny.el"))  5. Define your dependencies with Cask. Include undercover. For example, here’s a simple Cask file: (source gnu) (source melpa) (development (depends-on "undercover"))  6. Add a .travis.yml that specifies how to test your package on Travis. For example, see this .travis.yml and Makefile. 7. Commit and push. 8. Check your repository status in Travis to see if it ran properly. 9. Check your coverage status in Coveralls.io to see if it displayed properly. 10. Get the badge code from Travis and Coveralls, and add them to your README (probably using Markdown). You can get the badge code from Travis by clicking on your build status badge next to your repository name. Coveralls has prominent instructions for getting your badge. Yay! Incidentally, if you want to see your test coverage locally, you can (require 'testcover) and then use testcover-this-defun or testcover-start to instrument the macros and functions for coverage. Run your tests, then use testcover-mark-all to look at the results. See the documentation in testcover.el to find out what the coloured overlays mean. Edebug has a test coverage tool too, so you can explore that one if you prefer it. Additional notes on testing: 2015-02-03 Better Emacs Testing – index card #testing #emacs 2015-02-04 Yay, testing in Emacs – index card #testing #emacs Resources: ## Getting started with Emacs? Empty your cup Frustrated with Emacs because you’re just not as productive as you are with your old editor? Copying configuration snippets from the Web in order to force it to work like what you’re used to, but running into problems with conflicting code or obscure error messages? Here’s something I’ve realized. To learn Emacs well, try emptying your cup. This is the story as told on the C2 wiki: A master was trying to explain something to a student. Now this student was not a brand new student, but a senior student who had learned many things. He had knowledge and experience aplenty to draw upon. But each time the master tried to explain something new to the student, the student kept trying to hold it up against his own notions of the way the world is and how it ought be, and he was unable to see the lessons in what the master was trying to teach him. Finally, the master poured a full serving of tea into his own cup, and into the cup of the student. Then he told the student he wanted to give to him some of the tea from his own cup. He began pouring tea from his cup into the student’s cup, but the student’s cup was already full, and all the tea from the master’s cup spilled out over the cup onto the surface below. The student said, “Master, you can’t pour anything into my cup until I empty it to make room for what you are trying to give me.”, and the master replied “Yes I know.” “And I can’t give you any new thoughts or ideas or perspectives on life’s lessons until you clear out some thoughts that are already teeming in your mind to make room for what I have to teach you.” Then the master paused for a brief moment, meeting the student’s eyes with his own knowing look and calmly but sternly said: ” If you truly seek understanding, then first, empty your cup!” The student pondered for a moment with a look of absolute bewilderment. Then a look of enlightenment came over him, followed by a smile, and a look of receptiveness. The master started to explain again, and this time the student saw what the master was trying to say. 2015-01-13 Emacs and the beginner’s mind – index card #emacs #beginner It’s natural to get frustrated when you expect something should work a particular way and it doesn’t, or you’re used to working quickly and you have to slow down. “Why can’t I use Ctrl-X to cut? Why is it called ‘killing text’? Why doesn’t it work like __?” I know what that’s like; even after years of using Emacs, I sometimes still struggle to configure things that people who use other editors take for granted. Some differences seem easy to address with code you can get on the Net. But if you do that – if you give in to your initial discomfort – you may find yourself fighting more and more of Emacs as you go along, without the skills to properly understand or integrate your changes. It’s better, I think, to approach Emacs as a beginner. Empty your cup and let go of your expectations. Pretend this is your first editor. Go through the tutorial. Start with the basics. Try doing things the Emacs way. In the beginning, you might feel agonizingly slow. You may need to do this after hours instead of when everyone is counting on you to deliver a time-sensitive project. It’s okay to open up Vim or your previous editor so that you can get something done, while you keep learning Emacs in the background. It’s okay to use the menu and the toolbar while you get the hang of the most common keyboard shortcuts. As you become familiar with the system, you learn how to work within it. Slowly configure things. Get used to the changes before you introduce more. Eventually, you’ll understand the configuration snippets that other people post. Reading Emacs Lisp is the first step to being able to modify Emacs Lisp, and from there you can learn how to write Emacs Lisp. But you don’t have to start knowing that right away. Many people use Emacs for years before writing Emacs Lisp, and many people use it without customizing it. But if you start learning Emacs by getting frustrated with it and trying to force it to be what you want, you might never get to the point where you can enjoy it and work with it. Be a beginner. Give yourself time and space to learn, even if you feel you’re learning slowly. Then, as you improve your understanding and skills, you’ll learn how to coax Emacs to fit you even better. ## Let’s have a virtual Emacs conference in August – help me make it happen! Why August? It’s an arbitrary target, although it tickles my brain to think about celebrating my 32nd birthday with awesome people sharing awesome ideas. (Incidentally, I’ll also reach the point of having been using Emacs for about half my life – doubly neat!) Anyway. I think it would be great to have some kind of knowledge-swapping thing. Since I’m not particularly keen on travelling, not everyone can make it out to Canada, and it’s hard to make awesome in-person conference recordings anyway, maybe a virtual conference would be a great bet. I’m willing to spend what I would have paid for airfare on things like organization, speaker honoraria, and other good things. I enjoyed the Emacs Conference in 2013, and I think we should figure out how to have these kinds of get-togethers more often. Emacs Chats and Emacs Hangouts are tiny steps in that direction, and I’d appreciate help in making this and many other community-ish things even better. =) 2015-02-02 Imagining an Emacs conference – index card #emacs #conference #plans #organizing-people So here’s what I imagine a virtual Emacs conference might be like. People volunteer, and somehow we organize a schedule of fascinating talks. This could be a full day, or maybe we’d spread it out over a couple of half-days (maybe even scheduled for different timezones so that everyone has something they can interact with life). We use Google Hangout on Air or a similar platform that can stream and automatically record. There’s the speaker with slides and screensharing, and there’s a moderator who can pick up questions from IRC and Google Hangout in order to ask them out loud. We might even be able to pull off panel discussions. Afterwards, there’s a playlist and a webpage with all the videos/MP3s/OGGs, and people can share their notes/discussions/follow-ups. All this is immensely doable with the technology we have today. For free, even. Anyway, the technology should be okay. What about topics? Here’s what I’m particularly curious about: • New features in Emacs 25 (and beyond) • Demos, workflows, and setup tips for popular toolsets/needs (ex: awesome setups for Clojure/CL, Rails, Javascript, C++, Java, writing, research) • Fascinating uses of Emacs • Good practices for Emacs Lisp: automated testing, performance, reliability, coding style/idioms (maybe even workshops along these lines) • Demystifying cool stuff: how core modules work, how to contribute to Emacs • A hackathon: get package.el headers on everything! fix bugs! make improvements! document! • Emacs microhabits, learning • Workshops: intermediate/advanced use of Org Mode, Calc, ESS, and other powerful packages • Emacs community-building and sharing And people can suggest other topics, too. =) Maybe we can even figure out some kind of unconference setup: people suggesting topics they can share, quickly voting on what they’re interested in, and breaking up into separate “rooms” to share/discuss. 2015-02-02 Making a virtual Emacs conference happen – index card #emacs #organizing-people #conference #planning #questions An Emacs conference would be awesome. Here are my (pitiful) excuses for why I haven’t figured out how to organize one yet, and things I want to figure out (especially with people’s help): • Who might be interested in speaking? How does one go about organizing speakers, schedules, topics, tech, etc? I’m still slowly getting the hang of reaching out to people and inviting them to Emacs Chats. • Will people show up and ask questions? Part of me is worried that I’ll pick entirely the wrong date/time/topics and there’ll be awkward silence. • How can we handle questions? IRC, probably, so that people can chat about stuff too. I think I’m pretty comfortable at keeping an eye on stuff and repeating people’s questions. Or maybe people can join the Emacs Hangout if we can get the flow to be smooth? • Will the experience be pleasant and worthwhile? Maybe not as goosebump-inducingly awesome as being in a room with 80+ other Emacs geeks, but I think it will be worthwhile. • How can we harvest and share resources? Hangouts on Air will put videos on Youtube automatically, so that’ll be taken care of. • What would we need to do leading up to it? Something about a mailing list, and a webpage, and lots and lots of coordination. • Do I need to gain experience/confidence with smaller steps? Or maybe find some accomplices? Of course, if someone wants to organize an in-person one, that’s cool too. Especially in Toronto. That would be awesome. =) (Although I might be able to get to New York or similar places too…) My evil plans for a conference like this include: • Getting cool stuff out of people’s heads/fingers/configs and into a form that other people can look at, learn from, and link to • Ditto for good practices that can help us develop better code (performance) • Discovering resources and tips we might not have found out about otherwise • Sparking more conversations and follow-ups • Spurring people to create and share more resources What could help the Emacs community learn even faster? 2015-02-01 Accelerating the Emacs community – index card #accelerating #emacs How can we get more people sharing their configs, or learning from other people’s configs? How can we make it easier for people to share through blog posts, videos, animated GIFs, and presentations? How can we create spaces for people to connect, either with virtual meetups or in person? How can we swap interesting ideas, workflows, and mental habits? How can we improve our skills? How can we keep the conversation going? Mm. Figuring out how to do virtual conferences might be a good start. Also, I’ve got this idea noodling around in my head on having some kind of an intermediate/advanced Org Mode workshop: something that covers clocking workflows, table calculations, literate programming, data analysis, publishing. Figuring out how to do virtual workshops would be awesome too. Okay. First things first. Some kind of date and some kind of time, and some kind of help sorting out a schedule. August 8 and/or August 15, maybe? If librarians can hold an online conference through Google Hangouts, we should be able to figure this out too. (Librarians are super-cool!) If you have lots of experience in organizing virtual conferences or you have ideas for how to make this less intimidating for a non-organizer-y introvert, I’d love to hear from you in the comments or at [email protected]. Let’s make this happen! ## Digital index piles with Emacs: Rapid categorization of Org Mode items Somewhat daunted by the prospect of categorizing more than a hundred sketches and blog posts for my monthly review, I spent some time figuring out how to create the digital equivalent of sorting index cards into various piles. 2015-02-01 Digital piles of index cards – index card #indexing #organization #pkm In fact, wouldn’t it be super-cool if the items could automatically guess which category they should probably go in, prompting me only if it wasn’t clear? I wanted to write a function that could take a list structured like this: • Keyword A • Previous links • Keyword B • Previous links • Link 1 with Keyword A • Link 2 with Keyword B • Link 3 with Keyword A • Link 4 It should file Link 1 and 3 under Keyword A, Link 2 under Keyword B, and prompt me for the category for Link 4. At that prompt, I should be able to select Keyword A or Keyword B, or specify a new category. Inspired by John Kitchin’s recent post on defining a Helm source, I wanted to get it to work with Helm. First step: I needed to figure out the structure of the list, maybe including a sample from the category to make it clearer what’s included. org-list.el seemed to have useful functions for this. org-list-struct gave me the structure of the current list. Let’s say that a category is anything whose text does not match org-bracket-link-regexp. (defun sacha/org-get-list-categories () "Return a list of (category indent matching-regexp sample). List categories are items that don't contain links." (let ((list (org-list-struct)) last-category results) (save-excursion (mapc (lambda (x) (goto-char (car x)) (let ((current-item (buffer-substring-no-properties (+ (point) (elt x 1) (length (elt x 2))) (line-end-position)))) (if (string-match org-bracket-link-regexp (buffer-substring-no-properties (point) (line-end-position))) ;; Link - update the last category (when last-category (if (< (elt x 1) (elt last-category 1)) (setq results (cons (append last-category (list (match-string-no-properties 3 (buffer-substring-no-properties (point) (line-end-position))))) (cdr results)))) (setq last-category nil)) ;; Category (setq results (cons (setq last-category (list current-item (elt x 1) (concat "^" (make-string (elt x 1) ?\ ) (regexp-quote (concat (elt x 2) current-item)) "$")))
results)))))
list))
results))


The next step was to write a function that guessed the list category based on the item text, and moved the item there.

(defvar sacha/helm-org-list-candidates nil)
(defun sacha/helm-org-list-categories-init-candidates ()
"Return a list of categories from this list in a form ready for Helm."
(setq sacha/helm-org-list-candidates
(mapcar (lambda (x)
(cons (if (elt x 3)
(format "%s - %s" (car x) (elt x 3))
(car x))
x))
(sacha/org-get-list-categories))))

(defun sacha/org-move-current-item-to-category (category)
(when category
(let* ((beg (line-beginning-position))
(end (line-end-position))
(string (buffer-substring-no-properties beg end)))
(save-excursion
(when (re-search-backward (elt category 2) nil t)
(delete-region beg (min (1+ end) (point-max)))
(forward-line 1)
(insert (make-string (+ 2 (elt category 1)) ?\ )
string "\n")))) t))

(defun sacha/org-guess-list-category (&optional categories)
(interactive)
(require 'cl-lib)
(unless categories
(setq categories
(sacha/helm-org-list-categories-init-candidates)))
(let* ((beg (line-beginning-position))
(end (line-end-position))
(string (buffer-substring-no-properties beg end))
(found
(cl-member string
categories
:test
(lambda (string cat-entry)
(string-match (regexp-quote (downcase (car cat-entry)))
string)))))
(when (car found)
(sacha/org-move-current-item-to-category
(cdr (car found)))
t)))


After that, I wrote a function that used Helm to prompt me for a category in case it couldn’t guess the category. It took me a while to figure out that I needed to use :init instead of :candidates because I wanted to read information from the buffer before Helm kicked in.

(setq sacha/helm-org-list-category-source
(helm-build-sync-source
"Non-link categories in the current list"
:init 'sacha/helm-org-list-categories-init-candidates
:candidates 'sacha/helm-org-list-candidates
:action 'sacha/org-move-current-item-to-category
:fuzzy-match t))

(defun sacha/org-guess-uncategorized ()
(interactive)
(sacha/helm-org-list-categories-init-candidates)
(let (done)
(while (not done)
(save-excursion
(unless (sacha/org-guess-list-category sacha/helm-org-list-candidates)
(unless
(helm :sources
'(sacha/helm-org-list-category-source
sacha/helm-org-list-category-create-source))
(setq done t))))
(unless done
(setq done (not (looking-at "^[-+] \\[")))))))


The :action above refers to this function, which creates a category if it doesn’t exist yet.

(setq sacha/helm-org-list-category-create-source
(helm-build-dummy-source
"Create category"
:action (helm-make-actions
"Create category"
(lambda (candidate)
(save-excursion
(let* ((beg (line-beginning-position))
(end (line-end-position))
(string (buffer-substring beg end)))
(delete-region beg (min (1+ end) (point-max)))
(org-beginning-of-item-list)
(insert "- " candidate "\n  " string "\n")))
(sacha/helm-org-list-categories-init-candidates)))))


I’m new to fiddling with Helm, so this implementation is not the best it could be. But it’s nifty and it works the way I want it to, hooray! Now I can generate a list of blog posts and unblogged sketches, categorize them quickly, and then tweak the categorizations afterwards.

2015-02-01 Index card sketches and monthly reviews – index card #organization #pkm #indexing

You can see the results in my January 2015 review, or check my config to see if the code has changed.

My next step for learning more about Helm sources is probably to write a Helm command that creates a montage of selected images. John Kitchin has a post about handling multiple selection in Helm, so I just need to combine that with my code for using Imagemagick to create a montage of images. Whee!