Nick Zitzmann’s Symbolic Linker provides a way to create symbolic links from within the Finder. There have been a few times where I found myself wanting to create a symbolic link from outside the Terminal, so I gave it a try. It puts an item in the “Services” sub-menu that appears in the Finder’s application menu, and it also shows up in contextual menus and the “Action” button in the Finder toolbar (the one with the gear icon).

The icon in the Services menu is a bit plain, though.

Luckily, it’s open source, so I was able to fork it and add a simple icon modelled after the arrow overlay that the Finder stamps onto aliases and symlinks.

It won’t win any design awards, but it does the trick.

I opened a pull request, so hopefully he’ll take the change and release a new version, but the project hasn’t been active in a while, so if you’d like to grab this in the meantime, you can download my patched version.

Update, 10 April 2011: Nick has accepted the patch. That was quick! Thanks, NIck.

While on the topic of useful services that are trivial to do in the Terminal but a little annoying when you’ve already got a Finder window open, sometimes I find myself wanting to create an empty text file in a folder that I’ve got open in the Finder. Opening a text editor, then saving the file and having to navigate back to the folder is a little tedious. I went looking for a Finder service that could do this for me, and found an article from Mac OS X Hints that explains how to create one.

Why they didn’t just provide a file to download is beyond me, but if you want to save yourself the effort of going through the instructions, you can download the one I made, also with a custom icon.

Update, 10 April 2011: via Ellen Beldner on Twitter, today I coincidentally discovered cdto, which lets you add a toolbar button to the Finder to open the current window in a terminal. So for all of those other things that are more convenient to do with a quick command line, there you go.

I found an AppleScript on GitHub for centering the frontmost window. It didn’t do quite what I wanted, so here’s my slightly-modified version, which will center the window in your screen horizontally without changing the vertical position or size.

tell application "Finder"
	set screenSize to bounds of window of desktop
	set screenWidth to item 3 of screenSize
end tell

tell application "System Events"
	set myFrontMost to name of first item of ¬
		(processes whose frontmost is true)
end tell

try
	tell application myFrontMost
		set windowSize to bounds of window 1
		set windowXl to item 1 of windowSize
		set windowYt to item 2 of windowSize
		set windowXr to item 3 of windowSize
		set windowYb to item 4 of windowSize

		set windowWidth to windowXr - windowXl

		set bounds of window 1 to {¬
			(screenWidth - windowWidth) / 2.0, ¬
			windowYt, ¬
			(screenWidth + windowWidth) / 2.0, ¬
			windowYb}
	end tell
end try

Paste this into Script Editor or download the script file. Put the file in ~/Library/Scripts. Make sure you’ve got the Script menu turned on in the AppleScript Utility application. It will show up in there, and should work in most Mac applications.

I have found a couple of limitations. It doesn’t seem to work at all with Firefox, which doesn’t have very complete AppleScript support. It’s likely that there are other applications out there with missing or incomplete AppleScript support that this won’t work for either. The second problem is that there’s a bug in the Terminal application that moves the window upwards, even though the script is written in a way that’s supposed to preserve the vertical position. It would be possible to work around this, but I decided that it didn’t bother me enough to clutter up the code. If you want a workaround, post a comment and I’ll give it a shot.

The original script doesn’t specify a license, so I hope it’s OK to modify and share it. I figure that, since it’s published on GitHub, and the author releases a lot of open source code under very liberal licenses, that he’s probably not intending to keep very tight control over it. My changes are offered to the public domain.

I’m just as obsessive with making sure objects are lined up straight on my (real life) desk top. Sadly, AppleScript can’t help me there.

Update, 15-Nov-2010: This continues to be a fairly popular post, which a lot of people seem to come across through search engines. See the comments below for tips about ensuring that the window size doesn’t change, and for centering vertically as well. I’ve also noticed that this fails on multi-display setups, centering between the two screens instead of on the current screen. I’ll try to come up with a fix for that.

To make the situation worse, I was traveling for work at the time, 2,812 miles from home and my extra pair of specs. Luckily, I was in the second-least-horrible place in the world this could have happened: Washington DC. I grew up just outside the city, worked in it for six years, and spent most of my free time between June 1998, when I left school in Pittsburgh, and April 2005, when I moved to San Francisco, in the neighborhood where my hotel happened to be. I still know the city well enough that I was able to stumble my way around and find food for two more days without being able to read any of the street signs or storefronts until I was just about right on top of them. But it was not fun, especially when it came time to try to navigate the airports on my way home.

This is just the latest example of my notorious absent-mindedness. Just as with my eyesight, I have immense trouble keeping my attention focused without artificial aid. This plagues me in all sorts of different ways, from losing possessions, to chronic tardiness, to hobbies and projects that never really get off the ground. I’ve always been better at dreaming up ambitious plans than following through with them. I started writing this blog post over a month ago!

So, it was with complete earnestness and good intention that I published my personal objectives for 2009, and I made a good start on all of them, early in the year. As is often the case for New Year’s resolutions, I fell off quickly. I haven’t given up, though, I’ve just changed my approach.

I think it was a mistake to try to do all of them at once. Embarking on five projects at once is a great way to avoid focusing on any of them. I have to force myself to tackle one at a time.

The natural place to start is by getting myself organized. Without a good system for keeping track of all of the things that I want to do (or have to do), I tend to fall back on doing whatever occurs to me in the moment… and later stressing out about the things that I’ve forgotten during moments that I can’t do anything about them. As I mentioned in my last post, I’ve tried using systems based on paper or index cards for this before, but they never felt right. I really need the ability to sort, filter, and edit without having to spread things out across a table and keep a pile of blank cards on my person all the time.

I briefly tried some web-based applications, but they didn’t feel right either. I think it’s important to be able to capture ideas very quickly, at any time, with minimal interruption of my concentration. Requiring an internet connection—absent on the train and unreliable at other times—makes this impractical at times, and even when a fast connection is available, needing to go to my web browser, open a new tab, and load a site before being able to enter a new task is just enough of a context switch to make me lose my focus on what I’m doing.

So I quickly carved my choices down to the two most popular OS X tools: OmniFocus and Things. On their face, they are similar in more ways than they’re different. Both have a Mac application and and an iPhone companion that can sync with it. Both allow you to organize tasks around multiple dimensions (for example, the project it belongs to and the context you need to be in to do it). Both support repeating tasks, on-hold projects, deferred tasks and notes. Both have a quick entry window that can be called up with a keyboard shortcut to capture tasks without switching contexts. Both were built to support the GTD system, but also to be flexible enough to adapt to individual users. They each have devoted fans and a lot to recommend.

Things is a little newer, and has some great visual design. The user interface is simple and appealing, and it’s been promoted by its fans as the less complicated alternative. It supports flexible tagging of items, and has a very intuitive filter bar to limit your view to the items with the tags that apply right now. It’s also less expensive than OmniFocus.

OmniFocus, on the other hand, is a little more heavyweight, but also felt a little more stable and polished. It’s not quite as pretty as Things, but the UI feels more natural to me. It is a lot easier to use by keyboard, and it’s heritage as a descendant of outlining software makes it a really great way to organize thoughts that might start out as unstructured notes, jotted down in the middle of doing something else, and are later organized into multi-stage projects with smaller projects inside them. It may be more complex than Things, but the complexity mirrors the projects you’re using it to organize. It doesn’t need to be more complicated than you want it to be, but it doesn’t impose artificial simplicity on you either.

OmniFocus also has much better support for syncing across multiple computers than Things does. I switch between three different computers and an iPhone on a regular basis. OmniFocus handles syncing across the internet very well… maybe a little more slowly than I’d like, but with very few conflict problems and little effort required. For the most part, it “just works.” Things requires syncing to your phone over wi-fi, rather than syncing both the phone and the computer to an internet file server. This means you need to remember to sync your phone any time you make changes to your computer, or else you might find yourself at the grocery store with only half of your shopping list. The situation for syncing multiple computers is even worse: it requires use of a third-party syncing service such as Dropbox, and reports from users indicate that forgetting to close Things on one computer before opening it on another can result in a corrupt database. Ouch. Put those two problems together, and it makes it seem like syncing Things would require constant diligence and attention… in other words, I’d have to work around the software’s deficiencies rather than the other way around. That’s pretty much the opposite of the reason I’m interested in the software in the first place. Cultured Code, the company that makes Things, has said that better multi-computer syncing is their top priority for the next release, but I’ve learned in technology not to count your chickens before they hatch.

What’s more, during my trial of Things, I ran into a number of UI glitches and other bugs. It may look nicer in the pictures and screencasts, but OmniFocus felt more robust. This is not to disparage Things. It’s a new product and a few glitches are inevitable. But OmniFocus has the benefit of more maturity (though it’s only a couple of years old itself) and it’s still progressing pretty quickly. I had pretty much decided to buy a copy of OmniFocus when a 15% discount rolled into my RSS reader, courtesy of Daring Fireball. Sold!

A month later, I already feel like it’s helping, although I’m really only just getting started. One of the key insights in David Allen’s methodology is that the separation of capturing, processing, and acting on information helps to reduce overload. OmniFocus is really ideal for putting that into practice, and I realize now that the main problem with everything I’ve tried in the past is that they’ve only really covered capturing. Processing the information is too tedious with pencil and paper or basic to-do list applications, and it’s difficult to focus on the items that are currently relevant from one moment to the next.

Which isn’t to say that I feel totally in control yet. I still have much more that I want to do than I have the time and energy for, but what I’m hoping is that I can get better about juggling those things with the things that I need to do but don’t particular enjoy, and especially the things that I may think I need to do, but turn out not to be so important in the end.

What my name has going for it in simplicity, however, it lacks in uniqueness. Although my Googleability has risen quickly in the last year and a half or so, if you search for “Tim Moore” you’ll tend to come across Amos ’n’ Andy actor Tim Moore, ’70s AM radio soft pop singer Tim Moore, Michigan Republican Representative Tim Moore, or British travel writer Tim Moore before you find any mention of yours truly. The Wikipedia disambiguation page for my name doesn’t even mention me among the nine “people called Tim Moore.”

Besides the pseudo-famous Tim Moores of the world, I run into other like-named individuals pretty regularly. On two separate occasions during childhood I went to schools with other students named Tim Moore. Once I met a Tim Moore in a bar in DC. It’s gotten worse in the internet era. I’ve been mistaken on IRC for Common Lisp luminary Tim Moore. Even working at Atlassian, I was surprised to discover some posts on our forums that I didn’t remember writing, only to realize that I have a customer namesake there as well.

This is the reason, I suppose, that most people with common names — especially if they’re as geeky as I am — invent some kind of internet handle early on in their online lives. I’ve never been able to commit to one; it always seems too cheesy to me. My one past attempt feels regrettable now, and it looks like it’s been hijacked now by some other guy in Brisbane anyway.

So when I decided to buy my first personal domain name in 2002, I couldn’t think of anything to register other than my own name. Most variations of tmoore.com, timmoore.com, timothymoore.com, etc. were unavailable, but a new .name top-level domain had recently become available, and it seemed like exactly what I wanted. The way .name domains worked at the time, you couldn’t buy a second-level domain. Instead, second-level domains were reserved for surnames, and were shared between all registrants that have that name. Your first name was registered to you as a third-level domain, and an email alias was set up so firstname@lastname.name forwards to another address of your choosing. Unfortunately, tim.moore.name was already taken, so I registered timothy.moore.name and began to use timothy at moore.name as my preferred email address.

It’s been a great convenience using a forwarding alias for my primary email address. I’ve moved between several email providers in the last six years, and most of the people who send me email have been none the wiser. I haven’t had to update the dozens of web site accounts and mailing list subscriptions that are sending to my .name address, and for the most part, it’s pretty easy for people to remember.

I say “for the most part” because it hasn’t been without the occasional headache. For one thing, most people aren’t aware of .name domains; they haven’t exactly been a raging success. And for people who think all domain names have to end in .com, .net or .org — trust me, there are more than you’d think — sometimes it can be hard to convince them that, yes, that’s actually my email address. Even worse are the poorly implemented form validation schemes used by an unfortunate number of websites. In that case, no amount of convincing will help, and I’m forced to give out another, more conventional address.

Mostly I could live with these drawbacks, directing my frustrations towards the ignorant people that failed to understand how domain names work, rather than my own choice of an unusual email address. In any case, it was easier to work around the occasional misunderstanding than to change the address I had been using for so long. But a few months ago I decided to finally transfer all of my domains off of the tacky godaddy.com registrar and discovered that things were worse than I realized.

The .name top-level domain experiment has mostly been a failure for the Global Name Registry — the company that administers these domains. There are few registrars that support them at all, and even fewer that support inbound transfers. The scheme was so unpopular that they decided years ago to abandon the restriction on registering second-level names — the “moore” in “timothy.moore.name” — and allow unused ones to be bought and sold freely. In fact, most of the .name domains that have been sold since 2004 are of the second-level type, and of the small number of registrars that accept incoming .name transfers, an even smaller portion of them can handle the third-level domain transfer that I needed.

I found one, Gandi.net, that looked nice enough, so I started the transfer from Go Daddy. Once the transfer completed, I decided to change my email alias — it pointed to a Gmail account that I’m trying to move off of, and I figured that while I was in the middle of making changes, I might as well go through with that one too. The only problem was that I couldn’t find the place in the Gandi admin UI where the forwarding address is set. To my dismay, their tech support confirmed that there isn’t one. It turns out that the registration and transfer of the third-level .name domain email aliases is a completely separate process from the domain itself, supported by an even tinier fraction of .name registrars, not including Gandi. Even worse, the Global Name Registry’s confusing table of registrar capabilities incorrectly listed Gandi as supporting the email aliases, an error that has since been corrected after I alerted Gandi to the problem.

So I found one of the few registrars that does support the email aliases and once again transfered the domain. The only problem is that somewhere in the switch from Go Daddy to Gandi to 123 Registration, the email registration got lost. None of the sites seems to be aware that I own it; Go Daddy no longer shows me the option to transfer it out, and 123 doesn’t seem to have received it during the inbound transfer. The mail is still being forwarded to my Gmail address correctly for the time being, but I have no way to change the address that it forwards to.

It’s possible that I could get this sorted out if I go through negotiations between Go Daddy, 123 Registration and the Global Name Registry, but at this point, I give up. Dot Name is a failure and a giant hassle. I’m still registered until 2010, but I’m phasing the address out. Luckily, I’ve got this incrementalism.net domain running here at DreamHost. It’s been working out pretty well for me, so I’m officially changing all of my personal email over to tmoore at this domain. If you ever send me email, update your address books now, because timothy at moore.name will be going away once the domain expires. I’ve been slowly switching over all of my online accounts to use the new address, and it really is a big headache, so I hope I don’t ever have to do this again.

You may be wondering, “why incrementalism?” Well, I’ve had a long interest in incremental processes, in software development, project planning, public policy, self-improvement, music, biology, economics, cosmology… the list goes on. In many ways, it seems that it’s the key to reliable improvement in the world, and on a personal level I find that incremental thinking is the only way I can ever get anything accomplished. Which is not to say that it’s the most natural way for me to think. On the contrary, I all too easily get wrapped up in ambitious, overreaching ideas and endless preparation for projects that I rarely start, much less finish. So I chose the name not to describe myself, but to remind myself of what I want to become, and that it’s OK to make only small, slow progress towards my goals for now, as long as I can start again later and keep going.

Quoting artist Chuck Close, via Merlin Mann’s 43 Folders:

What I found that one of the nice things [about] working incrementally is that I don’t have to reinvent the wheel every single day. Today I did what I did. You can pick it up and put it down. I don’t have to wait for inspiration. There are no good days or bad days. Every day essentially builds positively on what I did the day before

try {
    s = new String(byteArray, "UTF-8");
} catch (UnsupportedEncodingException e) {
    throw new Error("UTF-8 is missing??");
}

This code is the result of two conflicting factors. On one hand, since the constructor in question takes an arbitrary character encoding, the case of the encoding being unavailable must be taken into account. On the other hand, 90% of code that calls this constructor will be explicitly invoking a character set that is required to be provided with the Java Runtime Environment, and its absence would be an error serious enough to justify terminating the VM entirely.

The unnecessary exception-handling code is ugly, and obscures the actual intent of the method in which it appears. Charles jokingly proposes adding a “yoda” statement to Java to tell the JVM, “do, or do not; there is no try.”

Another Solution

Usually, code smells like this indicate a poorly-designed API. If you know the method can be called in a way such that failure would mean there’s an internal error, then it shouldn’t be throwing a checked exception. As is often the case, you could solve this problem with stronger types:

public class Charset {
    public static Charset findByName(String charsetName)
        throws UnsupportedEncodingException {
        // implementation left as an exercise for the reader...
    }
    // ...
    public static class Standard {
        public static final Charset UTF_8 = //...
        public static final Charset US_ASCII = //...
        // etc.
    }
}

Then give String a new constructor:

    public String(byte[] bytes, Charset charset) {
        // no exception declared!
        //...
    }

Now you’ve got a few different ways to use this. When you know you want to use a built-in encoding:

    String s = new String(byteArray, Charset.Standard.UTF_8);
    // no checked exception here!

When you want to use a variable encoding, that may or may not be defined in this VM:

    Charset charset;
    try {
        charset = Charset.findByName(charsetName);
    } catch (UnsupportedEncodingException e) {
        System.err.println("Unknown charset: " + charsetName
            + "; falling back to US-ASCII");
        charset = Charset.Standard.US_ASCII;
    }
    String s = new String(byteArray, charset);

And the original String constructor could remain—rewritten to use the new Charset facilities—as a convenience for the case where you really do want to use an unknown encoding, and fail if it’s not present:

    try {
        String s = new String(byteArray, charsetName);
    } catch (UnsupportedEncodingException e) {
        System.err.println("Unknown charset: " + charsetName
            + "; ignoring");
    }

The Worst Part of it All

As it happens, Sun, did add a Charset class to Java in 1.4, as part of the NIO framework. Astonishingly, they still did not define constant implementations of Charset for the set of required standard ones. So you still have to look them up by name, and you still have to catch an exception! Worse yet, they invented some new exceptions for the purpose, UnsupportedCharsetException and IllegalCharsetNameException. These exceptions are unchecked runtime exceptions, which avoids the problem of having to clutter your code with exception handling code in the cases where you are using a standard charset, but makes it easier to mishandle cases where you aren’t.

The kicker, though, is that String does not have a constructor that accepts a Charset object! Instead, you’re supposed to use the CharsetDecoder class or the decode method of Charset, which wraps everything in Buffer objects, making you jump through a few hoops to accomplish the same things:

    String s =
        Charset.forName(charsetName)
               .decode(ByteBuffer.wrap(byteArray))
               .toString();
    // this might throw an exception, but it's unchecked
    // so we don't need to catch it unless we want to handle it

Ick.

Still, though, the NIO charset handling is a little bit better than what we had before, and it gives you some flexibility that wasn’t there in the previous implementation (for example, you can control how to handle unmappable byte sequences). It wouldn’t be too hard to add in a few utility methods to smooth over the rough edges here. I’ll leave that as an exercise for the reader.

My money is on wireless as the keynote’s theme. Obviously I’m not the first to say this, and the banners in the Moscone Center are a big clue, but you’ll just have to take my word that I’ve suspected this for a while now. It’s clear to me that Jobs and Apple’s industrial design team must not be big fans of lots of cables hanging off a computer (and who is?) so it wouldn’t surprise me at all if there are teams of engineers trying to build a perfectly cable-free computer at Apple. I don’t know if they’ve gone quite that far yet, but I bet that the sub-notebook that they’re almost certainly announcing tomorrow will be pretty close.

I’m typing this right now on a rev A 12″ PowerBook G4 that I bought in May of 2003. It’s reaching the end of its life — it won’t actually run on batteries anymore, so I need to keep it tethered to a wall — but five years ago, this was an incredible machine. It was compact, lightweight, fast, full-featured, and beautifully designed; it was one of the best computers Apple had ever created, and still is.

There’s absolutely no way that the notebook computer Apple is announcing tomorrow will be anything like the 12″ G4. That is, they’re not putting a MacBook in a smaller package. If they were planning to do that, it would have already happened. The MacBook Pro is a fairly incremental update to the same basic design that started with the Aluminum PowerBooks, and a smaller version of those would not be noteworthy enough to headline the keynote presentation.

Instead, I think we’ll see a radically new computer that not only looks like nothing we’ve seen before, but presents us with an entirely new way of using and even thinking about portable computers.

Many of the rumor sites have reported that the new design will not include a built-in optical drive. The assumption is that it will be available as an external unit, but I’m not so sure. I find it just as likely, or even more likely, that Apple will instead announce a shift to fully electronic software distribution, perhaps even selling third-party software, probably leveraging the iTunes Store. This rumored MacBook Air will receive all of its updates wirelessly.

I would not be surprised if there are no peripheral ports at all on the device. External devices will use Bluetooth. Backups will use wi-fi with an Airport Extreme AirDisk, a feature present in the Leopard development versions of Time Machine that slipped from the final release, but will very likely return tomorrow, maybe even with a new, Apple-branded hard drive or RAID array with integrated wireless. I am more hesitant to believe the rumors that they will announce ubiquitous wireless networking using WiMax, EDGE or EVDO, but it’s not out of the question and it would surely be welcome.

In the cases where you do need removable storage, the solution is literally right in front of most of us. I don’t think it was happenstance that many of the new features of Leopard were oriented around easier network setup, more flexible sharing, and remote access. I’ve got a feeling that the MacBook Air will be a computer that is explicitly designed as a companion device — one that is not intended to stand alone as your primary work machine, but to provide a portable window into the desktop machine that you most likely have sitting on your desk already at home or at work.

The pieces fit together perfectly: with Leopard’s Back to My Mac, Apple has already solved the problem of sharing files across the Internet, meaning that a portable device only needs to be powerful enough to get onto the network, connect to a host computer, and sync over whatever data you need here and now, or maybe even just act as a dumb terminal using screen sharing to control the desktop Mac directly. The limited need for speed, memory, storage and expansion ports then frees the hardware engineers to optimize for battery life, wireless performance, and weight. It could all add up to something pretty revolutionary: a truly ultra-portable computer that would not need to be much larger than a magazine but could potentially provide the power of a Mac Pro wherever you are.

Now, it’s pretty likely that a lot of my “prediction” is really more like projection. The fact is, this is exactly the kind of computer that I’d really like right now. I’ve got Mac desktops at home and at work, and I’m completely happy with them except on the occasions where I go out of town… or just feel like blogging from a cafe or browsing Google Reader on the couch. It’s hard to justify buying a full-featured laptop for those occasions, not just because of the price, but because of the hassle of keeping my data in sync, not to mention lugging it around in my bag. If the MacBook Air turns out to be anything like I hope, Apple will surely get more of my money tomorrow.