WriteMonkey: a lightweight text environment for Windows

I recently came across WriteMonkey, a very good “zen” — or minimal distraction — editor for markdown. This came along at just the right time for me to draft a couple of documents in a situation where I wanted to get away from the standard office software environment: I needed a bit of a break and wanted to just work in plain text with a little markup for a while.

WriteMonkey handled the task perfectly. It can push a document, styled per a custom style sheet or using its own built in CSS, to Word or HTML for printing or sharing — quite handy.

And then I discovered how much it has under the hood, and found that it’s more than an editor, but a full-on machine for working in text files. It has what it calls “jumps”: regular expression-based search terms that, when matched, can define the maching block of text with any arbitrary designation. Then a built-in navigator pop-up shows those blocks in a list. So, one could define a regex match with TODO at the beginning of a line and use the jump viewer to display all the TODO items in a file full of stuff. (This was the first thing I did, based on the tips at the writemonkey site).

I set up a couple more, too: A regular expression to show a particular header format in a journal file where I quickly dash off notes to myself, and one that shows the first part of text snippets from drafts of language I’m working on in other documents. There isn’t support for multiple windows (comes with the full-screen “zen” option), but WriteMonkey lets you quickly ctrl-tab between recent documents.

Finally, WriteMonkey has a built-in scratch space for every document, accessible via alt-r. It’s a great place for storing all those snippets and todos that accompany the main document, without cluttering up the main text. All that and it’s a portable app: No installation or anything required other than clicking the executable. In two days of use it was a huge help at creating a nice environment for doing the writing and organizing I had to get done.

Using Alfred to manage tasks

Recent updates to Alfred (my earlier post here) have greatly enhanced its capabilities to run local scripts and extensions. I’ve long used the Journal Tasks TextMate bundle in conjunction with geektool to manage and display a small to-do list in one corner of my OS X desktop, and now with Alfred I can instantly add items to that list. Quite slick.

Here’s the task list viewed in TextMate: Simple and no frills.

quick list textmate

And geektool displays it on the desktop using a bit of awk:

awk '!/@done/' ~/DropBox/SimpleText/Quick\ List.taskpaper

quick list desktop

I’ve set up an Alfred extension to add to the list using the “do” command:

alfred quicklist

The command in Alfred looks like this:

perl -p -i -e 's/^Quick List:\n/Quick List:\n\n- {query}/' ~/Dropbox/SimpleText/Quick\ List.taskpaper; growlnotify -m "Added item to quicklist"

It finds the header for the appropriate part of the list, and inserts the query passed to it at the top of the list. (Update paths as appropriate; I keep my quick list file in my DropBox folder.)

Growl provides a nice visual confirmation that the item has been added. I still have to open the file in TextMate to mark items as @done and periodically expunge completed items, but it’s great to be able to effortlessly add to the list.

The entire Alfred extension is at github.

Alfred is my favorite new launcher

Back in the day, Quicksilver was the hot app for OS X. I hadn’t used it for years, now; at some point it seemed to become unstable, and its indexing sucked up a fair amount of CPU. So until recently I’ve been launcher-less on my Macs. Oh I checked out the occasional alternative like Launchbar, but never took to it.

But now I’m using Alfred and seeing the launcher light once again.

Alfred is nicely capable on its own: Invoke it, type an application or file name, and Alfred displays the matches, each with a hotkey to activate. But with its Powerpack, it gets just fantastic, with dedicated shortcut keys to active popup finder navigation, a mini iTunes player and a Clipboard history. The keyboard shortcuts continue — each popup gives hotkeys to the options it presents.

These tools have replaced my normal modes of navigating on the MacBook. It’s so easy to invoke any of the powerpack features to find and email a file, fire up a playlist, or simply launch/switch applications. What I used to do with quicksilver, I’m now doing with Alfred, and loving it.

[The launcher app itself is free and available on the Mac App Store; the powerpack, which turns up the capability to 11, costs about $20. Worth it.]

Great Android apps: Vignette

I’ve been using the Vignette app for photography on Android ever since Dawn recommended it to me. It allows me to tap to shoot (avoiding the balky Droid X camera button) and offers a bunch of shooting options.

It also offers dozens of filters for creative photo-making, any of which can be applied either at the time of taking a shot, or later, to any photo in the Droid’s gallery. In fact, there are so many filters that I have trouble keeping track of all of them, and developers neilandtheresa (who, by the way, have an utterly charming blog and web site – and also see their official site for Vignette) continue to add more with each update to the app.

So I cheated and made myself a handy reference for the current set of built-in effects. It’s a little unwieldy to use on the droid itself, but not too bad — and it’s a big help for thinking about post-processing of photos that I’ve already shot. It includes examples of the vignette, coloring, camera and film effects styles and more. I hope it’s helpful to you. Click through for the full-size sheet at flickr.

Vignette App for Android | Effects examples

Keep in mind that the effects can be layered on top of one another via the customizations menu, allowing the stacking of any number of treatments. This sheet doesn’t show any of those combinations.

One hint for working with Vignette: Set a favorite preset with all effects, frames and customizations to Normal/None; then you can quickly toggle from fancy-pants artistic to straight normal settings.

For the sake of completeness, here’s a list of all the effects currently in the application (note that not all simple color variations are included in the example sheet).

1. Normal - Generic film effect
2. Vignette
3. Portra
4. Velvia
5. Ilford
6. Toy Camera
7. Toy Camera BW
8. Leaky
9. Cross-Process
10. Faded
11. SX-70
12. Summer - hazy grns and browns
13. Colourised - flat pastels
14. Oversaturated - bright washed out reds & yellows
15. Yearbook - faded B&W
16. Sepia
17. Platinotype - bright smooth tones & deep shadows
18. Retro Red - faded color variation
19. Retro Yellow
20. Retro Green
21. Retry Cyan
22. Retro Blue
23. Retro Magenta
24. London - contrasty b&w and red
25. Paris - contrasty B&W and blue-green
26. New York - contrasty black & white and yellow
27. Red/blue
28. Red/green
29. Blue/green
30. Rotate Hue
31. Sepia - same
32. Platinotype - same
33. Bleach bypass
34. Night vision- grainy and green
35. Duotone red, yellow, green, cyan, blue, magenta
36. Dreamy - soft-focus
37. Tilt-shift - portrait and landscape modes
38. Tobacco filter - deep orange tint for dramatic skies
39. Grad tobacco - portrait and landscape
40. Grad ND - portrait and landscape
41. Red, yellow, green, cyan, blue and magenta simple filters
42. Action movie - vivid reds w/blue-green tint
43. Technicolor - red and cyan 1930s look
44. Scary movie - tri-tone blue and magenta
45. Posterise
46. Blackboard
47. Infrared
48. Rainbow
49. Negative
50. Invert
51. Bordered
52. Rounded
53. Oval
54. Instant classic
	variants: Wide, mini & square
55. Instant transfer 1
	variants: 2 (smaller border) and 3 (yellow/magenta border)
56. Filed carrier
57. 35mm
58. 35mm full bleed
59. 6x6
60. 6x6 full bleed

Sync Lightroom Galleries to Android - Automatically!

Now that I have a photogenic, tiny gurgling creature in the house, I’m shooting a lot of photos, both on the Droid X and the Pentax. Most of these photos end up, one way or another, in Lightroom for cataloguing, and as I’ve described earlier, I have a nice workflow for updating these rapidly-growing galleries on my iPad.

But how about the Droid X? It has a nice screen, and I want to foist photos of my beautiful boy on anyone I happen across — so I started to wonder if, continuing to use Lightroom as my core platform, I could keep a small gallery of photos on the Android phone with as little manual work as possible.

Here’s the executive summary: I again use a smart published collection in Lightroom to create the gallery; then I use a LaunchAgent in OS X to monitor the mount point of the Droid X on the filesystem; and a tiny shell script syncs the published gallery to the Droid whenever I plug it into the MacBook Pro. Read on for altogether too many details.

First, a couple of things to note about how the Droid X generates image galleries [ note that this may apply to all Android devices; I have no idea, and your mileage may vary ]:

  • Android automatically displays galleries based on image type — so you don’t need to update a database or anything to build your galleries on the phone. You just need folder(s) full of images.
  • When you run the Gallery app, it will display galleries with the name of the parent folder containing the images. This means you can make a folder tree on the Droid’s SD card and neatly package multiple gallery folders within it, without cluttering up your root directory.

Prepare the SD card

When I attach my Droid X via USB to the MacBook Pro, it automatically mounts it as a volume titled NO NAME, so I used the Finder to change the label to DROIDX. This, happily, seems not to have affected any of the phone’s operations; the Droid must not depend on the name of the SD card for any of its internal work.

The second preparation step is to create a master gallery directory on the SD card. This is just for housekeeping purposes; everything in the galleries will be in a subdirectory of that top-level directory. Again, I simply did this with the finder: navigate to the DROIDX drive when the phone is connected, and create a new top-level directory, Galleries.

Your SD card and Droid should now be ready to go.

Set up the Gallery/Galleries

Just like last time, I’m using smart publish collections, based on keywords, to populate the galleries that will be synced. I decided to prefix all the keywords for this usage with dx — so, dx-gallery is my main tag, and I’ve edited it in LR to not be included in export. It’s a housekeeping tag only.

I’ve tagged a bunch of images with the dx-gallery tag.

Then it’s off to build the publish service. Here’s what it looks like in the publishing manager:

And add to that service a Published Smart Set that looks like this:

You can assign multiple keywords to the Smart Set, or create as many smart sets as you want galleries, and use unique keywords to assign photos to each. Each smart set within the published collection will appear in your directory tree as a subdirectory of the top-level folder for the set — and that makes the syncing to the Droid easy.

Automate syncing via LaunchAgent

Everything I know about LaunchAgent I learned from this tutorial. This is basically a concise repeating of that description, edited for our purposes. (I’ve previously described using this process to perform system backups)

First, if it’s not already there, mkdir ~/Library/LaunchAgents. This is the folder that OS X will watch for scripts triggered by system events such as mounting an external drive, which is exactly what plugging in the Droid does.

In that directory, make a new plist file (I called mine droid-sync-watch.plist) and give paste this into it:

<?xml version=1.0 encoding=UTF-8?> <!DOCTYPE plist PUBLIC “-//Apple Computer//DTD PLIST 1.0//EN” \ “”> <dict> <key>Label</key> <string>droid-sync</string> <key>LowPriorityIO</key> <true/> <key>Program</key> <string>/Users/alan/Library/Scripts/droid-sync</string> <key>ProgramArguments</key> <array> <string>droid-sync</string> </array> <key>WatchPaths</key> <array> <string>/Volumes</string> </array> </dict> </plist>

In short, this plist file tells the OS to run the identified script (~Library/Scripts/droid-sync) when the specified WatchPath changes.

The sync script itself lives in ~Library/Scrips and consists of a check against the desired volume (here’s where naming the Droid SD card comes in) and an rsync of the designated published collection to the previously-generated target directory on the SD card.

#!/bin/bash # delay a short time to make sure the path is available echo -n "[*]-- new /Volumes... sleeping" | logger sleep 20 if [ ! -e "/Volumes/DROIDX" ]; then       echo -n "[*]-- DROIDX NOT connected - Exiting" | logger       exit 0    else       echo -n "[*]-- DROIDX Connected - Performing gallery sync" | logger fi # rsync with delete option rsync --delete -r ~/Pictures/Exported\ Photos/Droid/ /Volumes/DROIDX/Galleries echo -n "[*]-- DROIDX gallery sync complete" | logger

Finally, tell the LaunchAgent controller to watch your scripts by doing the following at a terminal:

  • launchctl load ~/Library/LaunchAgents
  • launchctl list | grep sync

You should see your droid-sync script appear in the list produced by the second command, above.

Now you’re ready!

Plug in and go

That really should do it. When you connect the Droid X, you can watch the messages in the sync script appear in your console log, and everything should work — after syncing, disconnect the device again and fire up the gallery application; in the “Folders” section of the gallery you should see an item for each gallery you create in Lightroom. You’re done!

As with the iPad workflow, the great part of this is that once it’s set up, it’s pretty automatic. If you edit, add, or remove photos, as long as you republish the collection, those changes will all be pushed over to the Droid. Thanks to a little nerdery and Lightroom, we’ve built a bit of functionality that the Droid software doesn’t directly offer — and it’s still done with LR as the core of the photo library.

Tasks + Journal in TextMate

A couple of years ago (whoa now, three and a half years ago?!) I commented on using the TextMate Journal Bundle to keep a snippets log. I still use that same snippets file for some references and a handful of things that don’t quite fit in 1password.

When 2010 rolled around, I started up a new journal file to use for a little bit more writing, and quickly found that I wanted to mix content within that file — specifically, I wanted to add tasks and treat them more functionally than straight markdown list items. Henrik Nyh’s TextMate Tasks bundle handles to-do lists quite well, so I cobbled together a combination of the two bundles. A screenshot of some of these integrated journal+tasks lists is below:

JournalTasks bundle screenshot

Combined, I get the nice markdown-compatible writing of the journal bundle, plus its keywords, search, and folding capability, along with the nested list feature of Tasks.

Use the journal bundle’s dts and dtsp tab triggers to start new entries complete with date stamps (and clipboard contents in the case of dtsp). You can write text into any entry, and intersperse lists at any point by starting a line with - (indent with one or more spaces to create sub-lists; Tasks will love it). Toggle list items to complete with cmd-D, and cmd-E will remove expired items.

I like just being able to put lists into markdown-enabled writing, but there’s a nice Getting Things Done application here, as well: Since the folding in the journal bundle is so easy, you can make @context entries, fill them with actions, and fold them to get out-of-scope contexts out of the way. Drop the name of the scope into a keyword, and the Find in Bundle command will produce a nice list of the first entry in a given context that matches a search. It’s simple but workable for GTD, if you’re into that sort of thing.

A variation that’s even more direct GTD-style tasking is to use @context tags anywhere in your entries and then employing the “find tasks” command to display only the desired matches. Use either or both find commands to fit your style and workflow!

Note that the Tasks bundle is inspired by the very good TaskPaper app. If you’re interesting in something a bit more full-on for lists (and GTD) that also has a bunch of extensions and related projects, do check it out. (Since TaskPaper works with text, you can even load files from Tasks+Journal or Tasks right into it and maintain some (but not all) functionality. I’ve done a little bit of further tweaking to maintain that compatibility in my bundle, like change Henrik’s check-mark back to the “@done” syntax that TaskPaper users (and update the bundle’s commands accordingly), which lets me switch back and forth pretty smoothly.

The JournalTasks bundle is available at github.

Another year of photo data!

Following in the modest two-year tradition I’ve established (see 2007 and 2008 posts), here is my 2009 photo data from my Lightroom catalog!

[ quick howto: Lightroom 1 & 2 (and 3) databases are in sqlite3 format, which means that freely-available tools can extract data from them. I use sqlite3, some shell scripting, and R (and occasionally excel) to produce summaries of that data. Why? Data offers some insight into the kinds of photos I take. Mostly, though, it’s fun. I’d be happy to expand on the actual code that goes into these plots, if there’s interest. ]

Below is a set of plots that summarize some of this year’s data. Click through to flickr to see the larger version.

2009 photo data!

What’s interesting this year? Well, crop ratios looked pretty similar to last year, so this year, for the first time (suggested in a post by Keitha, whose photos I admire tremendously, and whose Pentax lens set I envy with the fire of a million anti-glare-coated nine-aperture-bladed all-metal suns) I pulled out some information about aperture for each of the prime lenses that I shoot with. You can see these four frequency plots (for each of the Pentax DA 70mm F2.4 ltd, FA 50mm F1.4, FA 35mm F2.0 and DA 21mm F3.2 ltd lenses) in the left hand column of the image. Right off the bat you can see that I shot a lot with the FA 35mm this year (which is confirmed by the “overall lens use” plot on the right column). In fact, I took that lens along as my sole lens on a few long weekend trips to Ventura, CA, and the San Juan Islands, and really loved its performance. It does great at large apertures, but I also used it a lot for street shooting at f/8 and smaller apertures.

Runner-up in frequency this year is the FA 50mm F/1.4, which ordinarily I would say is my favorite lens (and it very much still is; it just wasn’t as convenient a focal length to take as my only lens on those vacations). Its sweet spot [where it’s sharpest but still has a nice narrow depth of field] is about F/4, which is where I primarily use it.

Neither the DA 70mm F/2.4 or the DA 21mm F/3.2 got as much use this year, but I really love some of the photos I took with those lenses. In fact, I carried these two lenses specifically for their light weight and trim size on the Flagstaff photowalk I organized in July.

Car / Cat Ranch house / wide Crow Pomegranite Backside Doorman

How did 2009 stack up to 2008? In terms of absolute frequency, nearly identical! I kept 1308 frames last year, compared to keeping 1340 in 2008. Far fewer of those are picks, or posted to flickr — though a good number are waiting for me to come back to, to finish workup or to make a print.

And that’s it for the 2009 photo stats! I did re-work my keyword network code, so perhaps can follow up this post with a little more about keyword relationships.

If you’d like to know more about extracting and summarizing info from your own Lightroom catalog, please let me know (and check out my other lightroom-related posts)

And, as last year, I hope soon to follow up with a report on my 2009 photo goals, and to set a few for 2010.

Lightroom: Build thumbnails and full-size exports simultaneously

It would be great if Lightroom could string export presets together, to perform operations sequentially or simply to perform several processes on one image to produce several different outputs.

The first use I’d put to this functionality would be generating thumbnails of exported images right along-side the full-sized image — a common task when producing images to upload to a blog, for example.

Absent that kind of flexible functionality, here’s a nice solution for generating thumbnails of images and full-size exports at the same time. Use Jeffrey Friedl’s Run Any Command plugin in conjunction with mogrify: Just insert “run any command” to an existing export preset, and then add the following as the Command to Run (assumes you have LR2/Mogrify installed, which of course you do):

cp '{FILE}' '{NAME}'-small.JPG ~/Library/Application\ Support/Adobe/Lightroom/Plugins/LR2Mogrify.lrplugin/LRMogrify.extras/mogrify -resize 50% '{NAME}'-thumbnail.JPG

The command makes a copy of your original image (which is available to “run any command” plugin via the {FILE} token), with “-small” appended to the filename, and then uses mogrify to resize the copy to 50%. You can optionally adjust the percent to scale or add a “-quality” option to the mogrify command.

You could perform this command more cleanly, without the copy step, if you have ImageMagick installed independently of LR2/Mogrify: The full IM package includes the “convert” command, which allows for output to a new filename. Since I didn’t want to separately install ImageMagick, I just make a copy of the file and then invoke mogrify via the path to the plugin.

Presto! Instant thumbnails, appropriately named, to accompany your export. Pretty good stuff, made possible by the great work of Jeffrey Friedl. Check out all his lightroom goodies.

What's in your Lightroom 2 catalog?

A question recently came up over in the Flickr Lightroom group about generating a list of all filenames or selected filenames in a catalog. There’s a pretty nice straightforward bit of SQL that will produce just such a list.

My new favorite tool for poking around in the Lightroom database is the SQLite Manager extension for Firefox. It plugs seamlessly into Firefox and is a very good tool—faster than the old sqlite3 browser, and with the added bonus of not requiring Rosetta to be installed under Snow Leopard. Plug the following code into the “Execute SQL” box (or kick it old school via the command line sqlite3 tool):

SELECT pathFromRoot, baseName, extension FROM AgLibraryFile JOIN AgLibraryFolder ON AgLibraryFile.folder = AgLibraryFolder.id_local

You can do even better by using the sqlite3 concatenate operate in the select statement:

SELECT pathFromRoot || baseName || '.' || extension FROM AgLibraryFile JOIN AgLibraryFolder ON AgLibraryFile.folder = AgLibraryFolder.id_local

That will produce a nicely-formatted list of files:


Still building, we can add in the absolutePath field to get a complete path — very useful for when you have files stored in multiple locations, such as offline storage or backup locations.

SELECT absolutePath || pathFromRoot || baseName || '.' || extension FROM AgLibraryFile JOIN AgLibraryFolder ON AgLibraryFile.folder = AgLibraryFolder.id_local JOIN AgLibraryRootFolder ON AgLibraryFolder.rootFolder = AgLibraryRootFolder.id_local

And, finally, because how often do you really need to see the paths for all of the files in your library, really?, we can limit the query to just files in a quick collection. This takes a couple of extra steps, because we can’t directly get to the keyword data from the path data:

SELECT absolutePath || pathFromRoot || baseName || '.' || extension FROM AgLibraryFile JOIN AgLibraryFolder ON AgLibraryFile.folder = AgLibraryFolder.id_local JOIN AgLibraryRootFolder ON AgLibraryFolder.rootFolder = AgLibraryRootFolder.id_local JOIN Adobe_images ON AgLibraryFile.id_local = Adobe_images.rootFile JOIN AgLibraryTagImage ON AgLibraryTagImage.image = Adobe_images.id_local WHERE tagKind like "AgQuickCollectionTagKind"

And there you have it. One more fun trick you can pull thanks to the sqlite3 database that underlies your Lightroom 2 catalog.


Check out the rest of my Lightroom posts for much, much more, including more database tinkering, keywording, and workflow.

Replacing Edit in TextMate with QuickCursor

After upgrading to Snow Leopard on my MacBook, I found that the Edit in TextMate hook wasn’t working. There were a few threads about re-enabling it, but nothing definitive, and the support page suggests either running any target applications (those in which you want to use Edit in TextMate) in 32-bit mode, or perhaps trying some uninstall-reinstall voodoo. Since neither of these were ideal, I thought I’d try the “last-resort” suggestion, QuickCursor.

After a few minutes of use, QuickCursor seems to me to be a great improvement over Edit in TextMate — far from an “if everything fails” option, I prefer it for most of my uses.

  1. Installation is easy. Download, copy to Applications folder, and run it.
  2. Configure: I set it to load on bootup, and it automatically found TextMate as one of my editor options. I assigned TextMate the same keyboard shortcut that Edit in TextMate once occupied (cmd-ctrl-E).
  3. Use! From a Safari field, hit the shortcut and up pops a TextMate window; edit away, save, and your text appears in the Safari field. So far, just like Edit in TextMate, with the added bonus of being uncomplicated and functional in Snow Leopard. But here’s where it improves on the original: Edit in TextMate required the “target” window to be in focus in the target application; that is, when using Safari with multiple tabs open, the tab with the target “edit in” field had to be the active tab. This meant that if you opened an “edit in” TextMate window, then flipped through a few tabs to find something, you would have to relocate the target tab before being able to save from the TextMate window. QuickCursor doesn’t have this limitation: You can open multiple editing windows from multiple tabs, edit any/all of them, and save your edits without worrying about which application or tab is in the foreground. Bingo!

There are a couple of important caveats to QuickCursor that may make it not an ideal solution for some users (my bolds):

QuickCursor depends on two technolgies. For reading/writing data from the original application is uses the accessibility api. The nice thing about that API is that it’s not a hack, it’s a supported API. But unfortunatly not all views support the accessibility api (at least not read/write of the text content). And in particular webkit views don’t support it. And that means that tools that use webkit as their editor (such as won’t work with QuickCursor.

That means that Firefox doesn’t work with QuickCursor, either, since it doesn’t use the accessibility API. Since I’m a Safari user, and never much used Edit in TextMate for Mail, QuickCursor is pretty spot-on ideal for me.

Quick Lightroom 2 Tip: Show untagged images

I haven’t used Lightroom 2’s library filter extensively, but it’s really pretty powerful and I found a good use for it this morning. Having tagged a big batch of new images somewhat helter-skelterly, I found myself wondering if I could view just the images that I had not yet tagged, so that I could take care of them and be all done with this round of keywording. The library filter does this handily:

lightroom 2 metadata browser - setting presets

Open the filter pane (hit \ to activate and deactivate it), then select the “text” controller, and set it to “Keywords” “Are Empty”, and there you go: Lightroom 2 will display just the untagged images in the current view. Very handy, and the display will update as you proceed to tag, slipping newly-tagged images out of view.

I saved this library filter view as a preset using the dropdown controller available in the upper right of the pane, so I can quickly retrieve it any time I like.

Update: I see the following in a good post over at the O’Reilly Lightroom blog:

One of the example smart collections that is installed with Lightroom is Without Keywords. Take a look at the image count for this collection. If it’s anything other than 0 then get in there and add some keywords!

Nice! I haven’t much explored smart collections. That built-in collection is a great find.

Getting Things Done: Task Writer

I got a nice email this morning from Katy at Task Writer, asking me to take a look at their web app for getting things done.

It’s been a while since I considered myself an active devotee of the GTD methodology, so I’m a bit out of touch with the state of the art, but Task Writer looks to me like an app that is both a) pretty highly usable, and b) built with GTD in mind — that is, it’s not like a broader list-making web app like Remember the Milk or gubb, or an all-purpose tool like stikkit (rest in peace) that can be turned into a list-making app that can do GTD; rather, all the organizational elements of GTD are built right in.

Actions are organized by lists (inbox, waiting, someday, etc) and @contexts (@car, @computer, @email …) and can be further associated with specific projects and given due dates. A set of checkboxes along the left-hand panel of the app turns on filters that display only the selected tasks.

Task Writer tinkering

Adding tasks is really straightforward (I’d like to see the option to not put new tasks into a project – after all, that’s what the #inbox is usually for), and projects are easy to add/edit. There are a few interface quirks — Safari-specific, perhaps? Text doesn’t always seem to wrap neatly in column headers, for example, and the overall interface is a little wide on my screen.

For the most part, Task Writer seems to achieve a couple of things that are noteworthy: It’s specifically built for GTD, so there’s no obstacle to experienced users jumping in and immediately using it. But it’s also approachable enough, and starts with enough pre-built structure (a few lists, contexts, and projects) that one could use it without being a full-bore Next Action Acolyte.

I can see Task Writer really taking off. There’s nice room for some improvement, too: More keyboard shortcuts, a review mode (“what did I get done this week? last week?“), and being able to email/twitter tasks straight into it are features that could really give it a big boost.

If you’re looking for a new Getting Things Done-focused app or in the market for a capable list-making tool, I’d give Task Writer a good look.

Good Apps: 1Password

1Password is a password manager for OSX that performs smart form completion in your web browser. In the not-quite-a-year since I bought it, I’ve used it, in one way or another, just about every day. To make a long story short, it’s made simple, easy work of everything I do that involves a web password, login, or account information. And in that year, the software has only become more capable, adding increasingly simple syncing and great support for iPod/iPhone.

In a nutshell, here’s what 1Password does: It pays attention to the web forms you fill out — the login at the power company, for example — and, if you give the word, saves the information you enter into that form to a password-protected keychain (it knows when you’re filling out a new form, and prompts you for the okay to save it). Later, when you return to that form, logging in is as simple as a quick tap of a keyboard command: hit cmd-\ and 1Password fills in and submits the form, and boom there you are looking at your power bill, without any looking up your account number or anything.

I’m not using the power bill example for nothing. Paying bills is where, for me, the huge payoff of this app is: By removing all the overhead of looking up logins (finding the last bill for the account number or something), 1Password has massively reduced the overhead of managing my bills. See, it doesn’t just save your logins, it keeps a list that helps you to manage them. From that list it’s two clicks to select and log in to any given form, so checking all my statements, bills, and accounts is a simple matter of scrolling through the list and opening up any accounts that I think I might need to check. To check my credit card, for example, I used to have to pull out the card and type in the number, which inevitably took place on a sunday morning in the wintertime when I’m wearing my slippers and it’s snowing. The mental process was something like, “where’s my wallet? Oh, the briefcase. Wait, it’s still in the car. And the car is in the driveway with six inches of snow on it. I’ll do that later.”

And now? I skim the list in 1Password, click the name and then click the web form login to check my balance, make a payment — for every single bill or account I have. It’s too easy, so I just check in that Verizon bill any time I wonder how I’m doing. And about every three weeks I just run down the list and check all the accounts that involve money. Honestly, it’s awesome.

And of course it handles all those logins for social networking, webmail, my usermin control panel, mailing lists, and so forth. In fact, I let 1Password store just about every single login I have; when it’s so easy to save with the app, why take up any mental space with keeping a login that might be a one-off, after all? And beyond passwords, it keeps all kinds of other information, making it able to smartly fill in things like credit card payment forms. Further, it saves other “wallet” items (like passport numbers) and “smart notes” (ssh passwords).

With the mobile 1Password app for iPhone/iPod Touch, all of this information is accessible on the go. Agile built a web browser that’s highly — but not perfectly — functional for most uses, and it lives inside the app where it accesses your login information directly. Previously, Agile had built a wonky workaround to make that information accessible via a Mobile Safari bookmarklet that synced via Safari bookmarks to the iPod/iPhone. I have to admit that I’m still pretty fond of this approach, and although 1Password doesn’t update the bookmarklet any longer (removed for security reasons?), they can pry that bookmarklet from my cold dead hands. For one thing, Wells Fargo doesn’t like their browser one bit, recommending that I install Safari for Panther instead.

Multiple Macs? 1Password can deal. Just sync your 1Password keychain (either the OSX keychain or the new “Agile Keychain” format) and you’re good to go. For the past ten months, I used Unison to handle this syncing, but just recently switched to Dropbox, and it works like a charm to keep everything updated on both my current machines.

Finally (I know, I know), the single time I’ve needed to contact the folks at Agile for some tech support, they were on the issue promptly and responded personally. Nice.

What doesn’t 1Password do? It’s a short list. Logins for some sites — for my account with ING, and my mortgage account, for example — just elude its ability to detect and autocomplete. So it’s not perfect on that score, but it’s awfully good. Update Oct 25: Thanks to Carl at Agile Web Solutions, I have an answer to at least one of those tricky sites. Thanks, Carl! And I would love if it were capable of filling in items in Terminal, like those ssh passwords, but I think the devs have wisely focused on making it speak smartly to web browsers instead of a longer list of apps.

So. 1Password is really, really good stuff. Check it out.

Photography: Hitchhiker's Guide to Lightroom

I spend a lot of time in Lightroom 2 these days. I’m nobody’s pro, but I shoot a lot of photos, and after having used Lightroom (and now Lightroom 2) for a while now, I think I have a pretty good, simple, enthusiast-style workflow sorted out. I’ll summarize the workflow itself (importing through working up images) in follow-up post. Here are a few general tips that seem to work well for me:

Essentials, or Stuff I use constantly: I use Picks and keywords extensively. Reviewing newly-imported photos, I mark anything that I like right off the bat as a Pick by simply hitting shift-P as I scan through the gallery (and shift-X to immediately mark others as rejects; the shift modifier will mark the current photo and move on to the next shot). As I revisit a set of shots later, I find myself repeating this process; while those subsequent passes primarily identify further Rejects, I do occasionally find more Picks after starting to work up other photos. After each pass through a gallery, I use cmd-DELETE to remove (and delete) all the Rejects.

This has been a nice insight for my process: It means that I am fairly conservative when it comes to Rejects. That is, I don’t mark as Rejected 1) unless a photo is obviously bad (bad focus, blur, composition I really dislike, etc.) OR 2) until I’ve spent some time on photos in a set that I do like right from the get-go. This frequently helps give me a sense for appealing qualities of photos that I might not have noticed or thought of initially.

With a gallery through at least a first pass of identifying Picks and Rejects, I apply keywords. As with many aspects of processing photos, Lightroom has lots of ways to do this. There’s a jobber called Keyword Painting that I don’t use, because it’s always been much faster to simply select sets of photos and then apply keywords to the selection. In Lightroom 2, cmd-K focuses on the keyword entry box, which will auto-complete as you type. Lightroom 2 also has “recommended keywords” functionality, so that as keywords are assigned to a photo or set of photos, a new set of co-occurring keywords is identified and displayed for easy additional assignment.

Although I like to use a large-ish image preview (hit = to increase the size of preview images in the gallery grid) for screening for Picks and Rejects, for keywords I like to shrink the grid size (keyboard shortcut -). This fits more images into the grid and allows me to select larger sets for group assignment of keywords.

Lightroom allows for keywords to be nested, and there’s a great shortcut for accomplishing this: When entering keywords, separate child from parent keywords with a > sign: flickers > birds, for example, or burgers > food.

Simplifying, or Things I don’t use in Lightroom: Beyond keywording, Lightroom has at least a trio of way to identify and categorize photos: You can flag photos as Picks, label them with colors, and rate them with zero through five stars. I don’t use colors or stars at all. They may be highly useful for some situations, but they just clutter the cognitive space where I think about my photos: “Is this a three-star green photo, or a four-star blue one?” So except in the rarest circumstances, I haven’t yet found a use for ratings and color labels.

Indispensable keyboard shortcuts: There are grundles of these, but the shortcuts I use all the time are:

  • G, E, D: Gallery, Editor, and Develop modes
  • P: Mark as Pick (modify with shift)
  • X: Mark as Reject (modify with shift)
  • cmd-delete: Remove Rejects (optionally delete from disk)
  • cmd-K: Assign keywords
  • W: Jump to White Balance selector in Develop mode
  • R: Crop tool in Develop mode
  • J: Show clipped darks and highlights (Developer only; in gallery, changes display of thumbnails)
  • L: Cycle the lights (view on black)
  • tab/shift-tab: reveal/hide menu panels

Next time: The library filter, file organization, workflow, and Lightroom+Flickr?

Post to delicious with PHP and curl

This code is essentially all from Alex Schultz, reposted here for a handy local reference. I changed the api call to post, and added bits for tags and description.

When the original delicous-PHP code that I had been using stopped working, I hunted around for a new solution. There are a handful of big classes that didn’t do the trick for me, but this straightforward curl code works well. My single bookmarklet to post links to Txp and delicious is back in action.

On TextDrive Joyent servers, it’s probably necessary to enable curl support for PHP.

$dusername = USERNAME; $dpassword = PASSWORD; $api =; $link = urlencode($link_url); $desc = urlencode($title); $ext = urlencode($body); $deltags = urlencode(str_replace(,, , $keywords)); $apicall = https://$dusername:$dpassword@$api/posts/add?&url=$link&description=$desc&extended=$ext&tags=$deltags; $ch = curl_init(); curl_setopt($ch, CURLOPT_URL,$apicall); curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 2); curl_setopt($ch, CURLOPT_USERAGENT, php-curl); curl_setopt($ch, CURLOPT_RETURNTRANSFER,1); $xml = curl_exec ($ch); curl_close ($ch);

Update: Sometimes the https certification verification causes problems. Adding “curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);” appears to solve this problem.

mycrocosm beats me out of the gate

A little while back I had a fun idea: I bet I could use twitter to collect and store little, ad-hoc data statements; with a simple parser, those statements could be used to make data. A little ad-hoc database right inside twitter! I even got myself a domain name where I could tinker with it.

Well, mycrocosm beat me to it. It’s cool. It makes graphs. Rad. Exhibit A, on my time spent engaged with the Olympics:


Also. Tinkering with mycrocosm, I found Google Charts. Holy smokes!


And today I see daytum, another service of the same sort. It’s invitation-only, dammit. But it looks cool.

Frames and borders with Lightroom 2

Update 7/26/2009: There are some fantastic new features of LR2/Mogrify to check out:

  • Relative-sized borders (which I’ve written about before) are super.
  • As is relative-sized annotation text. No more calculating your scaled text size to apply to an export, since you can set the size to a percentage of image width or height. Very cool. (This goes for watermarks, too)
  • More border features! A checkbox for “identical borders” makes it much easier to set uniform borders. And inner borders are now supported for the creation of an inset frame with variable opacity.
  • Setting compression by file size: Specify a file size and LR2/Mogrify will compress the image accordingly so as not to exceed that file size.

Give these a try and don’t forget to donate to Timothy’s work if you find it of use.

Also, note that you can use Lightroom’s post-crop vignette feature to generate curved borders (in black or white) with less flexibility but also without plugins.

Update 12/21/2008: Much of this writeup now has more historical than practical value, since Timothy Armes has updated LR2/Mogrify to support multiple border options within the plugin’s own control panel. You can specify different-sized frames & borders without any extra monkeying around. Nice work, Tim!

A question recently came up in one of the Lightroom groups over on flickr about creating images with large borders on just one side — space within a frame to place a title, for example, but just along a single edge of an image. The poster wanted to create images such as those found here, and wondered if it was doable without diving out to an external tool like Photoshop. The first working proposal was to use a graphical frame applied in the print module, but that isn’t an ideal solution for me; it still requires setting up that frame with something like Photoshop, and to apply it you have to switch modes. So I tinkered a while with a photo I took a couple of nights ago, and managed to get what I think is a nice solution via a direct export from Lightroom using the fantastic LR2/Mogrify plugin from Timothy Armes.

The out-of-the-box options for this plugin don’t provide a capability to create different-sized borders to an image, but the underlying engine for the plugin, Imagemagick’s mogrify tool, does — after a fashion. So, in a nutshell, the trick is to use the command line element of LR2/Mogrify in addition to its other features, to add to the picture’s canvas size before performing the other operations.

Monte Vista neon

There are just a couple of tricks to get this to work smoothly using LR2/Mogrify. First is to add the extent command to the mogrify configuation, specifying the resulting size of the image you want to export:

I’ve specified the command -background white -extent 3008×2158 to be prepended to the mogrify command line that LR2/Mogrify will execute for me. I’m exporting an original image that’s 3008×2008, so I’ve specified 2008×2158 to the final image — adding 150 pixels, which will be filled with a white background. Next I use the built-in features of LR2/Mogrify to add the colored frames and the text overlay.

Because the extent command was applied to the beginning of the command line, the borders will be applied to the new image — the one with the bigger lower border created by extent.

The text overlay is just a bit strange. Note that instead of specifying the text to fall at the bottom, I’ve placed it at the top center of the image, with an offset of 2158 pixels. For some reason, directly placing it at the bottom center reverses the position of the new white border — it ends up at the top of the image, through some kink of mogrify that I can’t quite sort. It’s easy enough to compensate with the offset.

Export away, and that’s all it takes. You’ve built an image with a nice broad frame and caption, all right from Lightroom’s export panel. No Photoshop or print module necessary. Fun.

Lightroom 2: Related Keywords are Dreamy

As it happens, Lightroom 2.0 has just the thing I daydreamed about a handful of months ago. The new version’s data includes a table of keyword co-occurrences that makes it possible to produce things like this:

My flickr tag neighborhood

This graph shows keyword relationships that occur within a hop from my “flickr” keyword — which I use to keep track of photos that I upload there. In other words, it’s sort of a descriptive keyword neighborhood of what I’ve put up on flickr.

Color is a little subjective. The darker blue, the higher the ratio between unique neighbors and total neighbors. That is, darker blue nodes are connected to relatively few unique other neighbors than the lighter blue nodes.

Of course, you could use any focal keyword for this kind of thing: Starting with a lens-specific keyword would produce a rough map of the neighborhood associated with that lens, and might reveal how I tend to use that lens. The possibilities are pretty endless — and totally a fun kick in the pants to tinker with.

Keywords in Lightroom

[ Interested in my keywording workflow or duplicate keywords posts? ]


The last time I wrote about Lightroom, I was using sqlite to pull out frequencies of focal length. This time it’s keywords: Lightroom lets you build any number of custom keyword sets to apply to photos. It automatically builds a set of “recently used” keywords, but I thought it would also be handy to have a set of my most commonly-used keywords. While Lightroom has a command to export a list of keywords, that list doesn’t include frequencies. Keywords are stored in Lightroom in a table called AgLibraryTag (AgLibraryKeyword in Lightroom 2, see update below). Conveniently, Lightroom writes a count of each keyword to the same table, so it’s easy to get out all the information we need. (Note: The frequency in this table is a cached value and may not reflect the up-to-the-minute reality within your database. Rather than constantly update its databases Lightroom seems to update this count when you view the discrete keywords. I’m not sure how to force a library-wide update of all keyword counts. This is probably close enough, and is simpler/quicker than counting keywords image-by-image.)

Rather than run this data through R to build a histogram as I did with the focal length data, I just use awk this time to make a list with the most frequently-used tags at the bottom. With this list, you can easily build a corresponding tag set in Lightroom.

Remember to change paths to suit, and that (on OSX) you’ll probably need to upgrade your version of sqlite for all this to work. Also, always always work from a copy of your database as this script does.

# display a sorted list of lightroom keywords (Lightroom 1 only) cp ~/Pictures/Lightroom/Lightroom\ Catalog.lrcat ~/lightroom.lrdb /usr/local/bin/sqlite3 -csv ~/lightroom.lrdb 'select ImageCountCache, name from AgLibraryTag where kindName="AgKeywordTagKind";' > /Users/alan/lr-keywords.csv awk -F , '{print $1" "$2}' lr-keywords.csv | sort -n rm ~/lightroom.lrdb rm ~/lr-keywords.csv

Daydream: A map of how keywords relate to one another would be awesome.

Update: The above daydream is now possible with Lightroom 2’s related keywords functionality. Write-up here.

Update again (Oct 4 2008): The old code didn’t work with Lightroom 2 due to some things moving around in the database. The below seems to fix it and obtain keyword frequencies for LR2:

# display a sorted list of lightroom keywords # Updated for Lightroom 2 cp ~/Pictures/Lightroom/Lightroom\ 2\ Catalog.lrcat ~/lightroom.lrdb /usr/local/bin/sqlite3 -csv ~/lightroom.lrdb 'select ImageCountCache, name from AgLibraryKeyword;' > /Users/alan/lr-keywords.csv awk -F , '{print $1" "$2}' lr-keywords.csv | sort -n rm ~/lightroom.lrdb rm ~/lr-keywords.csv

Photo tool nrrdery

Update 1/1/2009: I’ve built some much more sophisticated sets of stats from my Lightroom 2 catalog.

Update 6/27/2007: Lightroom v1.1 is out (it’s real, and it’s spectacular, see the O’Reilly Lightroom Blog for more), and it changes the database from a “library” to a “catalog.” In terms of this little tool, this change seems to only entail changing the filename referred to in the wrapper shell script — as I’ve done, below. Otherwise, generating a focal length histogram seems to work just as it did previously.

Camera Nrrdery

For fun: You can see that I use my fixed 50mm and 21mm lenses far more than anything else I’ve got. That’s because they’re so very pretty.

I use Adobe’s Lightroom to manage my RAW photos. It’s a wonderful, splendid tool. Among its features, it provides a handy metadata browser of your photo library, and includes the ability to browse by lens. Recently James Duncan Davidson mentioned being interested in plotting his use of various focal lengths, and commenters responded with a number of good solutions. Since Lightroom uses a SQLite database for its library, tools like SQLite Browser can be used to scan through the database file itself and export tables, at which point it’s straightforward to grep and find focal lengths. This is pretty slick all by itself, but I thought I’d put together a quick tool to automate the extraction and generation of this data. To do that, I use sqlite3 from the command line to dump the metadata table to a file, and then a short bit of R code finds the focal lengths and builds the histogram. The sqlite3 commands and the R code are invoked via a shell script that makes a copy of the main database to work with and cleans up the temp file when it’s all done.


If you made this this far, you might actually be interested in how it’s all done. After some tinkering, I found from Jeffrey Friedl’s Blog that Lightroom’s current database needs a newer version of sqlite3 than that which ships with OSX. With that update installed, sqlite3 will handle your Lightroom database without any problems.

Here’s the shell wrapper. Change paths to suit:

#!/bin/bash cp ~/Pictures/Lightroom/Lightroom\ Catalog.lrcat ~/lightroom.lrdb /usr/local/bin/sqlite3 -csv ~/lightroom.lrdb 'select xmp from Adobe_AdditionalMetadata;' > /Users/alan/lr-metadata.csv R CMD BATCH /Users/alan/bin/lr-getfocallengths.R rm ~/lightroom.lrdb rm ~/lr-metadata.csv convert ~/lr-focallengths.pdf ~/lr-focallengths.jpg

And here’s the R code, which lives in lr-getfocallengths.R and is called by the shell script. Again, fix paths for your own circumstances:

lr <- file("/Users/alan/lr-metadata.csv", "r") lrlines <- readLines(lr) temp <- gsub("(/1)", "", lrlines[grep("exif:FocalLength>", lrlines)]) lengths <- as.numeric(gsub("([^[:digit:]])", "", temp)) lengths<-lengths[lengths<=1000] pdf("/Users/alan/lr-focallengths.pdf") hist(lengths, main="Histogram of Focal Length Use",    xlab="Focal length (mm)", ylab="Number", breaks=seq(0,200, by=4))

A few things to note:

  • Depending on how your version of R is compiled, you can use jpeg(…) instead of pdf(…) to make the output file. My R isn’t currently compiled with jpg support, so I build a pdf file and then use convert on it.
  • There’s some noise in the metadata that leads to the erroneous identification of focal lengths like 83456000. That’s not right at all. I skim off everything above 1000 in line 5 of the R code. (Which is still sort of silly. My longest lens is presently 200mm.)
  • Relatedly, the x axis of the histogram only goes up to 200. To change that, modify the seq(0,200, by=4) accordingly — you can change the upper bound as well as the width of the bins.
  • A really slick way to do all this would be to properly parse the exported table in order to combine data, in order to limit the data to, for example, “favorites” by focal length. These aren’t in their own fields in the database, however, but rather all within a single column that holds all an image’s metadata, which makes it harder to select on multiple conditions. That’s a trick for another day.

Posting other peoples' hints: Watermarks in LaTeX

I found myself today with the desire to incorporate a bit of watermark-ish text and graphic into a LaTeX document. The regular graphics commands don’t work very well with this, so I went googling and found the code below.

Note that the following isn’t my tip, but the page that references the code points to a 404 link. I tracked down the google cache to get the original link back out and thought I’d share.

   \usepackage{eso-pic}    \usepackage{color}    \usepackage{type1cm}    \makeatletter     \AddToShipoutPicture*{%     \setlength{\@tempdimb}{.5\paperwidth}%     \setlength{\@tempdimc}{.5\paperheight}%     \setlength{\unitlength}{1pt}%     \put(\strip@pt\@tempdimb,\strip@pt\@tempdimc){%    %\makebox(0,0){\rotatebox{45}{\textcolor[gray]{0.75}{\fontsize{5cm}{5cm}\selectfont{Draft}}}}    \makebox(0,0){\includegraphics[scale=1]{../figures/LETTERHEAD.PDF}}     }    }    \makeatothe

There are two makebox lines present. Uncomment the first to use a text or stamp the output of another command on the page; or use the second (replace the filename) to use a graphical watermark. Also, remove the asterisk from the opening AddToShipoutPicture command to have your image stamped on every page, rather than just the first.

TextMate GTD

2010 update: Ever ready to tinker with organization schemes, I’ve done some adaptation of the Journal and Tasks bundles for TextMate to produce another, very very lightweight way to implement a Getting Things Done routine in Textmate. Check out the JournalTasks bundle if you’re so inclined.


Haris Skiadas, who has made massive contributions to writing in LaTeX with TextMate (see for example his screencasts of good use of the LaTeX bundle), has put together a super TextMate GTD bundle. Haris has been hacking on it nearly-continously for several days — I confess to having harassed him significantly throughout development so far — and the bundle is a fully-capable GTD system: You can work with a single document, or as many as you want, can easily move projects around, add tasks, and add and modify contexts. The bundle has a number of commands to generate Next Actions lists, and it will archive completed tasks/projects to a separate log file.

Up until now, I’ve been using the Kinkless GTD system. Lately, however, that software began to feel a little cumbersome, a little too cognitively heavy and opaque. Since it lives in TextMate, Haris’s GTD bundle works with pure text, making highly extensible, and it works great (it even knows how to convert your Kinkless document to its own format). Today Haris capped it off with a script that filters an inbox (fed via Quicksilver) into your GTD documents. Seriously cool. I highly recommend giving it a try if you’re using either TextMate or GTD (or need an excuse to give either one a test drive).

New-to-me Spotlight feature

I’ve spent the last several days digging information out of a set of files, essentially coding variables from a large group of archives. Previously, I’d only used Spotlight occasionally, but for this kind of data digging, Spotlight really, well, shines. Calling up Spotlight and telling it what I’m looking for brings up a short list of relevant files. That’s not new, but what was new to me is what Spotlight does next: When the file is opened, simply hitting CMD-G (for Find Again; works great in text files, Safari, Firefox, Mail) takes me right to the correct section within the file. This won’t work so well if the search string appears lots of times in the file, but if the file is a long list of mostly-unique records, it works great. I’ve used Spotlight’s similar ability to navigate directly to a reference in a PDF, but this was new to me, and slick. Even when the right document is already open, it often is far easier to invoke Spotlight and enter the search terms than to switch to the right application (which often means find in a long list of apps) from where I’m entering variables. All day long, it’s like Spotlight is reading my mind.

A wiki without the wacky

... That’s what some are calling Backpack, the newest web tool from the people who brought you Basecamp and Ta-da-list. I haven’t used either of those, as they were released just as I was trying out yet another organizational scheme of my own, but I am intrigued by Backpack’s promise of free-form but still useful organization. Per the “wiki without the wacky” tagline, I’m assuming that Backpack will use some simplified wiki-like syntax to denote do-lists and flag information of particular kinds. Sounds pretty neat.

Update: Hey, cool. I got a “golden ticket” to give Backpack a try (thanks to Jason Fried, and, I presume, technorati tags), and have been poking around with it for fifteen minutes or so. First impression: Pretty neat! I’ll write a bit more later after I make some progress on the syllabus revision that’s due tomorrow.

Google does maps

I was going to make this a simple link, but played around with Google Maps for a few minutes and found it too cool for a one-liner. As the top-level page of Google Maps suggests, you can search for directions, businesses, and locations. Try searching for “sushi in Tucson”—bingo! There’s a map with locations plotted on it. Another click gives you directions to or from any location. Mapquest isn’t nearly this slick.

Enter “tucson to flagstaff” in the directions search, and up comes the map straightaway; there’s no tabbing between all the address/city/state fields. If you know airport codes, enter them directly, to get directions from TUS to Ventana Canyon (for your golf weekend), for example. Want more detail about that freeway on-ramp? Click on any of the numbered waypoints for a close-up.

But it gets cooler. Find your location, and then click-drag on the map. It moves. Finer control? Use the arrow keys. See more in the tour.

Update: Hublog weighs in, saying that while Google Maps is pretty cool, “it still doesn’t beat the flying, zooming Java beast that is map24.” Java beast indeed, but the zoom is way cool.


I spent a good chunk of this last weekend at Heather’s office, where they have chairs and desks purchased within the last decade — quite a difference from my own bomb-shelter steel desk at school. While there, I watched Heather do some of her work, which this weekend mostly consisted of creating and analyzing some GIS data.

Let me say that I consider myself relatively computer-savvy. I pick up concepts pretty quickly, can do some programming of a few different types, and feel comfortable with lots of different software on several platforms. So, I like to think that, you know, I get computers. But watching Heather work in GIS, well, I see that I just don’t get GIS. At all.

GIS is powerful. If you’re someone like a grass and fire ecologist, you can use it to map historical fire activity and predict the scope of future fires by hooking your GIS data into a statistical package. You can plot presence points of invasive species and build models of its future distribution. You can make really bitchin’ maps. But you first have to get it.

GIS, first of all, has this immense and complex vocabulary descended from various ways of making and describing maps, which is then crossed with technological vocabulary for rendering data: Topologies, cartographic mapping, vector- and point-based data. After a long day of cranking GIS, Heather routinely comes home and — after telling me what is wrong with the swamp cooler — speaks this foreign mapping language for thirty or forty minutes at a stretch. On top of all this conceptual complexity is the fact that the software — all of it, as far as I can tell — basically defies intuition. You’re thinking, “Hey, I like maps. They’re neat.” Well just try downloading GRASS GIS, a mature, open source GIS package, and see if you can do something with it.

The same goes for the molto-expensive GIS packages made by folks like ESRI, who seem to own much of the commercial GIS market. For example, one problem (and this reminds me of the balkanization of various open source projects) is that the complex vocabulary that I referred to earlier changes with your software package. What ESRI’s ArcView calls “themes,” ESRI’s ArcInfo calls “layers.” The same company’s package calls something by two different names! Ack. It’s madness, and try as I might, I still can’t decipher just what Heather does all day. “Maps,” I tell people. “Ah, stuff with maps.”

About, the short version

I’m a sociologist-errant. This site is powered by Textpattern, Pair Networks and the sociological imagination. For more about me and this site, see the long version.

RSS feed