An Alfred Workflow for Together

As you might have read this week, I started using Together as a database and file manager. One of the main reasons is that the files and folders are stored in a human-readable way, and you can work with those files independent of the Together database being open. This means getting things in and out is pretty easy, especially with the provided script library.

However, those scripts work mainly by manually launching the application and moving files into the most recently used database. This might be fine for most people, but it’s less than ideal for my current workflow. For starters, I don’t want to be pulled away from my current window so that an app can launch. Secondly, I want to be able to choose the database used for file import. Plus I just love tinkering with Alfred, so I wanted to see if I could script something that could handle my use-cases. I thought it might be useful enough to share.

This Alfred workflow starts by finding all of the Together databases on your computer using the “script filter” method. With the modifier keys, you then have three options—all of which save or move files to the Inbox of whichever database you select.

Here’s how it’s configured:

  1. [no modifier] Save webarchive of current Chrome tab to database. This requires that you install the webarchiver command line tool.

  2. [cmd modifier] This creates and then opens a new plain text file in the selected database, with your default text editor app.

  3. [ctrl modifier] This moves the selected Finder items into the selected database.

You can download the workflow here, and be sure to let me know in the comments if you have any questions or suggestions for improvement.

Getting Together, or, Quick Thoughts on Database Software

I’m writing this post from inside Together, a database application that I’ve been testing for the last two weeks or so as part of a concerted effort to find a new file manager and personal database utility. Back in grad school I got really deep into DevonThink, which remains unparalleled for full-text searching and finding connections between files. But soon after I discovered the wonderful world of Markdown, renounced hierarchical folder organization, and swore I would never look back.

Then I looked around recently and noticed that my files were a total mess. So I opened DevonThink, checked for updates, and realized the app hasn’t seen a full version upgrade in six years. Seriously: I searched my Gmail, and they alerted me about the public beta of version 2.0 on December 19, 2008. The current version is 2.8.1. And frankly, it feels that old. The UI—which was never particularly friendly—now seems downright hostile.

So I went off in search of something new, and I thought I would post some quick thoughts for anyone else in the market

Below are my thoughts on three applications—chosen almost at random—that I thought might work for me, based on three vague criteria: they could store a whole mess of files, appeared to be in active development, and were less than $50.

Evernote (“free”, or $49 per year)

I discovered Evernote right around the time I was starting to really get into plain text, which meant it was a non-starter for me. I was excited by the very recent iOS/Yosemite update, but my opinion of the service hasn’t changed much. It’s basically rich text files locked down so tightly inside a database that there isn’t even a real way to batch export your stuff. The larger problem, of course, is that when you’re in the app you can’t escape the feeling that you are in a storefront, where you can buy cloud storage, “premium” features, and a $240 backpack. It gives me the same icky feeling I have with many “free” cloud-based subscription services, like Todoist.

Which is a shame, because there are some powerful features lurking in there. It remains the only system I know of for reliable text recognition of handwriting, and the “atlas” feature—where you can find notes based on the location where you wrote them—is just plain cool. Additionally, iOS integration is as tight as they come. I get why so many people like it, but until they get Evernote Plain Text Edition going (for an additional $4.95 a month!), it’s just not for me. I’ve been thinking about using it for scanning some of my personal notebooks, but I’m not sure how much I can before bumping into the storage limits

Ember ($39)

Let me say this right up front: Ember is not a full-fledged database app, but I really wish it was. It’s designed for graphics and web professionals, and when I first saw it splash across the app store I thought it was an overpriced desktop version of Pinterest. But having worked with it for the full trial period, I think it’s probably the the most well-designed app for gathering data from your computer and the web. I’m not sure the folks at Realmac have designs to flesh it out into a robust database application, but I’m keeping an eye on it’s development with my fingers crossed.

Here’s what the app gets right, and the list is long: intuitive and elegant design, Dropbox storage, reliable browser extensions, built-in browser and RSS reader, a lovely iOS app, the ability to create and edit plain text files within the database, and the ability to import files of nearly any type. The problems I have with it are that I want it to do things it simply wasn’t designed to do; I recognize that this is my fault, not theirs. If they decide to implement full-text search and highlights of PDFs and other files types, and not limit the RSS reader to images, then this is an app I could see myself working in all day. And even though the database is pretty locked-down, the benefits of the user experience can outweigh that, for me. I’m much more willing to let apps ingest my files when the overall experience is great.

Together ($49)

What Together lacks in some of the elegance of Ember it more than makes up for with it’s power and flexibility. In many ways, it feels like an more modern DevonThink with a nicer feature set, which is probably why I feel most comfortable here. It’s most important feature is that it’s really the first database system I’ve come across with a truly transparent and human-readable file system, which—double bonus!—you can store on Dropbox.1 While there aren’t browser extensions, the developer has provided lots of additional scripts for pulling information in and out of the app. It also a sidebar widget called the “shelf” that functions much like DevonThink’s “drawer.” I much prefer menu bar items to these kinds of things, but still: it’s there if you need it, and it can can be turned off if you don’t.

Because of the storage system, Together gives you the power of a database with the flexibility of the file system. Even though I love the idea of tags as opposed to folders, they’re still a useful part of my workflow. They’re especially helpful for iOS apps that read from a specific folders. For example, I like to set Editorial to read exclusively from a folder that stores blog posts like this one. An additional bonus is that you can write scripts (including Hazel ones). I’ve already worked up some Alfred workflows for interacting even more deeply with multiple Together databases; I’ll post those later in the week.

I’m not sure how many Together users there are out there, but hopefully we can unite and share some tips and tricks.

  1. This is an entirely different post, but the much-maligned iTunes is a notable exception. In fact, I credit iTunes as the first app which made me realize how powerful databases could be if you put in the time to have accurate and consistent metadata.

Choose to Start Doing, aka, Tracking Your Work Time

In the many hours I’ve spent trying to log and capture various aspects of my life, I’ve found that straight-up time tracking can be one of the hardest to get right. It’s easy to see how many hours a week I am physically at my office—for example—but it’s much less easy to track how productive those hours have actually been. It’s great to use an auto-tracking service like Rescue Time, but even that is good only up to a point: sometimes I’m legitimately using Twitter and Facebook for work, and other times I’m not.

Ultimately, the best way to track my time spent at work is to do it myself, which is much less sexy and fun than doing it with cool automation and services. But I have found two tools recently which have made it pretty pleasurable: the very literally named doing and choose. Here’s how they work, and how they can nicely work together with Apple’s Reminders.


Doing is a command line tool from Brett Terpstra (who else?) that acts as a work log. Essentially, you just type what you are doing into Terminal when you start a task, and then again when it’s over. If you don’t have the Terminal open all day (I certainly don’t), then you can use this Alfred workflow. By far the best feature is the option for --totals, which will print how long you have spent on projects or categories (entered as “@tags”) over any given amount of time. The feature set is extensive for such a small tool, and it’s worth reading the full documentation.


Though doing doesn’t directly integrate with any services out of the box, the fact that is a plain-text command-line tool means you can pretty much do anything you want with it. Over the last few weeks, I’ve found that I use it more reliably when it links directly with my to-do list items. I use Apple’s Reminders, which for my money (none!) and my workflow (OS X) is still the easiest solution for tasks. To get things flowing smoothly, I created an Applescript that will find your uncompleted Reminders and write them to a text file, with each item’s list appended as a @tag. Here’s the script:1

tell application "Reminders"
	set output to ""
	repeat with i from 1 to (count of (reminders whose completed is false))
		set theReminder to reminder i of (reminders whose completed is false)
		set reminderName to name of theReminder
		set theList to name of container of theReminder
		set output to output & reminderName & " @" & theList & linefeed
	end repeat
	do shell script "echo " & quoted form of output & " > /Users/path/to/Reminders.txt"
end tell

Now, the real fun comes in when you hook this into Alfred and use the choosing CLI. Once you install that into usr/bin, you can pipe into it. Using Alfred workflows and some really simple scripting, you can cat into your file, search for a task using Choose, and then have it auto-start in Doing.2 Check it:

I still haven’t figured out how autocomplete these tasks back in Reminders/Doing, but I’m working on it…

  1. This thing comes with some serious caveats. Since 10.9, osascript for Reminders has essentially been broken. In 10.10, I’ve found that AppleScripts dealing with Reminders work relatively well, but only within Script Editor. So, in order to run this, I actually run an Applescript script that opens the file in Script Editor and runs it from there. It’s a pain, but I run it on my server so it stays out of the way. I’m not sure I would recommend running this on your everyday work machine.

  2. The workflow is three steps: keyword with no argument; run script cat ~/path/to/your/Reminders.txt | choose; run script doing now "{query}"

Restore Foursquare Checkins with Launch Center and Pythonista [Updated]

With the recent update to Foursqure 8.0 for iOS, the ability to “check in” at locations has been officially offloaded to Foursquare’s sister app, Swarm. This wouldn’t be a huge deal if Swarm wasn’t so greedy—it forces you to have GPS location on at all times, and subsequently drains your battery and/or bombards you with notifications. And while it’s nice for people who rely on the social features of the app, it’s really frustrating for people like me who used Foursquare mainly for personal logging and other location-based things made possible with its IFTTT channel.

So, just for fun, I whipped up a Pythonista script over the weekend that logs you in to Foursquare without the annoyances of Swarm. You simply fire the script, enter some or all of the name of your location, and then the Foursquare API handles the rest. In its current implementation, there is one serious caveat: you can’t choose your venue from a list. Basically, you enter a search term and then the script chooses the top result. Unless you are in a place with a lot of similarly named locations, I think you’ll be fine. And if you know how to code a better solution, I would love to see it—I’m super new to Python(ista).

Here’s how it works.

Create an “App”

The first thing you need to do is log in to the Foursquare developer portal, which you can do using your normal login credentials. From there, select “My Apps” from the top and then the green button for creating a new app. You only need to fill in some basic information, but pay special attention to your redirect url, since you’ll need this later. If you don’t have your own webspace, you can actually use almost any url, including this one ( Once that is done, copy and paste your Client ID and Client Secret and save them in a text file. They are important.

Next, you need to authorize yourself as a user of your new web app. The easiest way to do that is to go to the following web address, replacing CLIENT_ID with your Client ID and YOUR_REGISTERED_REDIRECT_URI with the URI that you entered earlier:

Once you do that, you should kick back to your URI, except with a trailing string that includes #access_token= followed by your actual access token. Again, keep that in a safe space along with your Client ID and Secret.

Run the Script

Once you have those three strings, you’ll need to plug them into the Pythonista script.

As you can see, the script uses the Foursquare API to search for locations, then it takes the top result and checks you in. It shows a little pop-up to let you know where you checked in, and then it kicks you back out to Launch Center, because I’m assuming that’s where you started the script from. You can always lop off that line or change it if you want to go somewhere else.

Let me know how it goes on Twitter or in the comments.

Update (August 25th)

After talking about this on Twitter, Ryan came up with a really elegant solution that uses a table view and lovely icons as opposed to my blunt force search method. As a bonus, he also created a dedicated home screen launcher.

View it in action here, download the script here, and look into custom home screen launching here. Thanks, Ryan!

How to (Sort of) Sync TaskPaper files with BusyCal

Recently I switched my task management workflow from Apple’s Reminders into a Taskpaper system that uses a unique instance of nvALT when I’m at my computer, and Listacular when I’m on the go. While I like this arrangement, I had really gotten used to being able to view tasks in a calendar layout so I could easily see what was coming up next. It’s not hard to make a master list of upcoming tasks from your Taskpaper files, but then you end up with just that: another list.

After some Googling I saw that BusyCal has a URL handler, making it possible to pass arguments into a string and create new entries from them. I wrote a rough script that reads from Taskpaper-formatted files and sends them over to BusyCal. There are some severe limitations here, including no way to account for @tags (which I don’t use anyway), and no provision for duplicate entries—this will add entries every time, even you already have identical entries in BusyCal.

Set-up: This is based on storing multiple Taskpaper files in a single folder. Those files should have the same names as your BusyCal Reminders lists.

Like so

Once you have that established, you can run the script, which should be pretty self-explanatory. It can handle lines with and without formatted due dates. You’ll need to change the directory in line 8, and you can change your file extension to whatever you use in lines 8 and 20.

Obviously, this is not a sync solution—it only works one way, and I think it works best for simply viewing your upcoming items. So when I make changes to my Taskpaper files and re-run it, I literally delete all of the BusyCal todos first.1

That being said, if you do make changes in BusyCal (like dragging items to change their due dates) I have sort of figured out a way to bring those changes back to your Taskpaper files, but it obliterates any formatting, headers, notes, etc. in the original files—basically anything that is not an explicit to-do item. Still, if you also want to give that a try, you can use this Reminders to Taskpaper Applescript.

Would love to hear how (or if) this works for you on Twitter or on the Gists.

Taskpaper to BusyCal Script:

  1. I found the easiest way to do this is to set the sidebar view to show dated to dos for the next year. Then you can simply select all and delete them.