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.





How Political is Food?


Last week I wrote a post on Alice Waters and the politics of food that went live over on TTBOOK on Thanksgiving. It’s something that’s been stewing since I read this New Yorker article on “foodie culture,” and is essentially a response to it. The post got branded an “essay” somewhere in the chain before it went live, but I think it’s a little short and informal for that; it’s really more akin to something I would post here than a fully fleshed out “essay,” but you get the picture.

I’m hoping to do more pieces like this—both written, and, eventually, audio—and the TTBOOK website gives me a nice platform for doing so. I’m probably not going to post here every time I produce something, but I’ll tag my posts so you can follow along via RSS if you’re so inclined.

The article

The RSS feed





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

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.

Choosing

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}"





Revolution Remixed


Apologies for the “radio silence” (couldn’t resist) on this blog as of late, but as you likely know, I have been busy working on actual radio. My first two months here at TTBOOK have been an exciting and exhausting crash course in the ins and outs of public media. I’ve been working on digital initiatives large and small, including a ton of content for an upcoming mini-series on death and dying, as well as some more blog-like posts which I’ll hopefully be able to show off sooner rather than later.

In the meantime, the staff has also been very patiently working to get me up to speed on audio and broadcast production, and the first piece that I (mostly) edited went live yesterday. It’s an interview with none other than movie-star-turned-revolutionary Russell Brand. After making headlines for expressing his politics of non-voting on British television, he decided to devote a full book to explaining the rationale behind his position on voting—as well as income inequality, meditation, etc. I don’t want to editorialize here (something about the ethics of my job?), but in my edits I did my best to accurately depict the tenor and content of the conversation he had with our producer Charles Monroe-Kane. I’ve embedded the piece below, but you can also have a listen on the site or in the podcast stream.





Time Lapse Audio


Legendary New York recordist Tony Schwartz came up in conversation at work today, and one of my colleagues mentioned “Nancy Grows Up,” a time-lapse audio essay documenting the development of his niece. While I consider myself a pretty big Schwartz fan (and a proud owner of a vinyl copy of New York 19), I had never heard this piece. Once I did, I was blown away, and haven’t stopped listening since:

Unlike time-lapse video, the sound segments themselves are not sped up, they simply cover a long range of historical time—in essence making this the female and sonic counterpart to Richard Linklater’s Boyhood. [Is there a mini essay in that idea?] Anyway, it turns out the piece has been featured on an episode of Radiolab (of course!), and has been the subject of a think piece on media and history. For more info on Schwartz, check out David Suisman’s story in Smithsonian Folkways Magazine.





Making Knowledge


My first week on the job at To the Best of Our Knowledge has been a crash course is seeing how radio gets made—and it still hasn’t lost any of the magic. This morning I sat in as next weekend’s show on “dual identities” was mixed. Pictured, left to right: producer Rehman Tungekar, host Anne Strainchamps in the recording booth, and engineer Caryl Owen. You can just make me out as a reflection above Anne’s head.





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 (http://craigeley.com). 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:

https://foursquare.com/oauth2/authenticate?client_id=CLIENT_ID&response_type=token&redirect_uri=YOUR_REGISTERED_REDIRECT_URI

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!





50 Stars


The American history nerd in me is happy to recognize that today marks the 55th anniversary of Hawaii’s statehood—and with it the 55th birthday of the 50-star American flag design. This image, taken from the Eisenhower Presendential Library, shows the official flag schematic that accompanied Executive Order 10834:

Despite what the Internet Archive might have you believe, then-President Eisenhower did not deliver a speech by William Jennings Bryant on the occasion.1 Instead, he just said a few words wishing Hawaii happiness and prosperity. Have a listen:

  1. For unknown reasons, the speech identified at that link as Dwight D. Eisenhower’s Hawaii Statehood Proclamation Speech is actually William Jennings Bryant’s “Against Imperialism” speech, recorded at the Democratic National Convention in Kansas City on August 8, 1900.





The Visual Microphone


In the 1858 edition of Wild Scenes and Songbirds, Charles Wilkins Webber speculated that sound waves might live on forever:

That a sweet sound should ever cease to be seems to me unnatural—at least unpoetical—for, let its vibrations once begin, though they may soon die to our gross sense, must they not go widening, circling on, stinging the sense of myriad other lives with a mysterious pleasantness (such as will overcome us in a wood upon an April day), until the uttermost bound of our poor space be past, and yet the large circumference go spread and spreading tremulous among the girdling stars? It may be so for all we can tell!

Webber’s notion of the perpetual sound wave has been shared by many writers, recordists, and sound engineers over time, who have dreamed that sound is always out there, and it is just a matter of learning how to capture it. Though sound is often generalized as being “temporal,” there is actually a nice line of thinking that has always imagined sound as infinite, stretching out through time and space, impacting everything around it until it girdles the stars.

Last week, a group of researchers at MIT made this previously speculative fantasy something close to a reality, with a process they are calling “the visual microphone.” The device is actually a high speed camera which can detect minute vibrations of objects in a room, and then translate these vibrations back into sound using an algorithm, even when the recording happened through soundproof glass. The results are not the highest in fidelity, but they are quite real, and quite good. Watch for yourself here:

This video (and many subsequent articles) inundated my Twitter feed last week, but perhaps no one said it better than my friend Nate Brown, who wrote to me, “The world has its own language.”