@mikemccracken: It would be cool if there was a way for well-used & loved GUI software to gracefully show its age, like a good leather wallet…

I still like this idea, and I loved the example that Bryan Knight replied with – the OS 8 Color Picker crayons, seen in the third “Colour Selector” image on the OS 8 GUIdebook page.

However, it just occurred to me that it’d be hard to design a UI that shows its age or use gracefully without looking “dirty” and triggering the kind of OCD that makes some of us empty the trash just because the icon looks full. I can think of a few other things that do that to me:

• Of course, the full trash can
• Unread counts of all kinds
• MS Word 08 showing “[Compatibility Mode]” in the window title for files that aren’t .docx format
• Badges on files in the finder that show source control status – I tried this once and it drove me crazy

There are probably more. Share yours in the comments if you like. I’d also be really interested in other examples besides the crayons where UI changes gracefully as you use the software more…

There’s a built-in way to generate “notes”, which was geared towards Acrobat Reader – it basically makes a double-wide PDF page and Reader will show the ‘notes’ page on the second screen. (I’m guessing it assumes your laptop screen is arranged on the right of your presentation screen, it’s the same size or bigger, etc…)

This doesn’t work for my personal favorite PDF reader, Skim – but luckily there is a full explanation of how to make it work on the Skim Wiki: Tips and Tricks page. The short of it is you create three tex files – one with all the content and two wrappers that generate two versions of the same presentation. One version has slides and the other has notes. Then you can set up Skim to auto-scroll the notes PDF as you move through the slides PDF in presentation mode.

Big thanks to whoever wrote that tip – and to Christiaan for making such a great app.

Jesper at waffle is starting an open-source web browser project to revive the spirit of OmniWeb, called rouse. He coins the phrase “delight innovation”. I love that phrase. He’s talking about taking a browser, something that’s relatively stable, and looking for ways to make it noticeably better again. I love that impulse – it’s something I’m hoping to see in email clients too.

Another place that delight showed up (along with Surprise and Joy), was at 52 weeks of UX in a post called “design for delight”. That post seemed to be a little more about the parts of design that don’t affect functionality, but do add personality. I really agree with this angle too – I like a program that has little details that are just for fun.

The Workstation - RIP 2010?

Marco Arment wrote yesterday about mobile computing being more exciting than what he called “Desk” computing. I’m a fan of Marco’s writing, and I usually agree with him, but that post got me thinking. I can’t argue that mobile isn’t exciting, but I disagree with his assertion that desktop computing is a solved problem. He’s right that the pace of innovation has slowed. Certainly the last couple of OS X releases have fewer and fewer compelling differences. In fact, I’m writing this on OS X 10.5 — 10.6 didn’t impress me enough to make me bother upgrading.

Still, when Marco asks what I want out of 10.7, I think “what don’t I want”?

I think there’s tons of room to improve on and even rethink the workstation.

Maybe now that the consumer train has shifted toward more custom-designed tools for browsing, games, and social apps, there’s room for workstation OSs to grow in ways that might improve them without worrying about leaving the home user behind (or boring them).

I’m not asking for unintuitive design. What I’m asking for is powerful tools – system and apps – for people who use computers for work every day. I certainly hope that these power tools will be built with elegance and style. I’m not asking for dual cameras and four speakers.

Market forces have limited development of crucial daily-use work tools to what will appeal to the home & leisure market. For instance, Apple ships Mail and iCal with the OS. Both are fine programs, but are clearly trying to ride the line between work features such as meeting planning, and consumer features like stationery. Meanwhile, the market for alternatives is limited, and even some of the alternatives have taken the approach of adding consumer-related features. Postbox, for instance, has added facebook and twitter support. That’s not helping me get work done – quite the opposite, really.

But am I really just talking about incremental improvements and a few more work-oriented features here and there? I don’t think so. To be more specific about what kind of big improvements I think are possible in desktop systems, I did a few minutes of brainstorming. Here’s what I came up with:

Like the personal jetpack, I’m still waiting for the system that knows what I’m trying to do and co-ordinates to help me get it done. The one that learns (even crudely!) about my habits and the time of day, my colleagues, their schedules, etc. The one with this knowledge baked in everywhere in the system. For instance, it knows which app’s notifications can be ignored for later.

As a start, I’d even settle for a single system that actually uses all the good ideas that have come up in the past 30 years. Let’s at least catch up to Douglas Engelbart’s vision of the NLS system for augmenting collective knowledge work before we call it a day.

Good search everywhere has been a real improvement, but what about full support for smart annotations for files, events, people and other data? The BeOS file system comes to mind. Search is better when there’s better info to search for. If I push it a little, some smart background prediction of categories for documents that’d help me find them later — that couldn’t hurt. Why doesn’t a file know who emailed it to me?

Another blast from the past – maybe OpenDoc was a stretch, but more open document formats and easier flowing data between applications isn’t a bad idea – can we expand on that?

This one ties in with mobile devices – Real, honest to god multi-computer network syncing. It can be done – it should be baked in! What if your filesystem was actually an easily merge-able version-controlled document oriented database like CouchDB? Can we use some ideas from distributed version control to make sharing documents on disconnected filesystems work right automatically? I still think the best solution doesn’t depend on storing everything on servers (especially public servers).

That leads to the oft-repeated idea of getting rid of “saving”. I shouldn’t have to commit changes – maybe I want to tag a version, but the data should always be written to disk.

Every app should be able to know about communication (mail, IM, SMS, whatever) that might affect what you’re working on in it. Today’s apps have uniform access to your files – but not to your messages. This seems like a bad historical distinction – they’re both relevant data. For example, why do I have to “save attachments”? It’s already on my disk…

What about application and system scripting that really works – that’s easy enough for quick things but powerful and fast enough to grow a real program from? Let me start them as visual or spoken one-off commands but then edit and share them as text.

System support for Quicksilver/Launchbar/Ubiquity-style text command lines. Tie this into the scripting system. Make it feel like I tell the computer what to do instead of finding the right app to tell, opening it, etc.

System-wide hypertext – I should be able to create robust links between document parts, messages, people, and other entities. It should be fast to view an annotated list of changes across versions of a document, showing who did them and what they said about it in emails. This shouldn’t have to all reside on some central server to work.

Do you have any ideas to add to the list?

So, I started a separate blog on Tumblr to explore email clients, called mike checks mail.

The idea is to look at clients available now on OS X, and discuss their features and their flaws. It’s basically very focused app criticism.

The first few posts have focused on the three free apps I use daily – Apple Mail, GMail and Thunderbird. Eventually I want to explore the other major mail clients currently on the market, including Entourage, Postbox, Eudora, and Outspring. I’d also like to dive into other platforms, to avoid reinventing something smart that’s been in (say) emacs for 30 years.

Take a look, and send me questions and suggestions for topics. Let’s geek out on mail clients…

I decided I’d share what I’ve learned recently to make getting started a little easier. I’ll give a short description here and post the resulting code to bitbucket at py-launchd.

Note: This was written and tested on OS X 10.5.8 with the default /usr/bin/python, version 2.5.1. Since I wanted to use multiprocessing, I used the backport to 2.5 available at google code: python-multiprocessing . For convenience, it’s included in the repository, and so is its license.

Goal

What we’re trying to do is have some python code that gets called when launchd notices someone connecting to a UNIX domain socket. UNIX domain sockets are local-only, so this is ideal for agents that only serve local apps. We’re also using launchd “agents” not “daemons”, so we’re assuming that it’s OK to have one agent process for each user. If you’re managing access to something that needs to be unique system-wide, then this won’t work (but you can still use Launchd).

launchd overview

The launchd process will read a launchd plist you give it (at login, via launchctl or the 10.6 framework), and listen on the socket you tell it to. Once it sees a connection, it’ll start the agent program you specified in the plist, and that program can make some calls using the launchd C API to get a file descriptor for the socket that was connected. This is important – you don’t need to call bind() or listen() on the socket, because launchd already did. It’s just handing the open socket’s file descriptor straight to you and your code can just call accept() on it.

Using launchd with Python

You need to create a C/ObjC tool that can do the launchd check-in to get the open file descriptor, then pass that off to your Python code. This is pretty straightforward using the Python framework included in OS X and the Python C APIs.

What I’ve done is create an agent loader that I called PyLaunchd that loads and runs server code in Agent.py. It expects Agent.py to be in the same directory.

PyLaunchd is built separately and copied into the test app’s Resources folder with an XCode script phase.

I have the app delegate copy PyLaunchd and Agent.py to ~/Library/Application Support/PyLaunchd/ on loading. It also customizes the launchd plist to set the path correctly for the current user, then writes that to ~/Library/LaunchAgents/, and loads it. (Actually it first unloads it, then reloads it. I’m not convinced this is the right way to do it). It uses system() to call launchctl, but I believe in OS X 10.6 there’s an API you can call to do it directly.

Finally, the sample app is really simple – it just opens the socket using the multiprocessing Client class, and sends whatever you type. The example Agent I’ve included will ROT13 it and send it back.

Please let me know if you have any comments, questions, or improvements.

For the BibDesk open source project, we wanted to have legit in-app apple help, as well as a web page (and PDF), without maintaining separate sources, since we were all working out of spare time.

We tried a few free options, and eventually worked out something decent with Texinfo, a latex-like markup language that can be processed into latex (and then PDF) or HTML.

I wrote a custom init file to have the (standard) texi2html script print out apple help compatible HTML. One post-processing script and a simple xcode script build phase later, and we get apple help.

We also get a version a little more suitable for the web (more content per page) from the same source: http://bibdesk.sf.net/manual/

It’s worked well for a couple of years, and it’s a good choice if you don’t mind learning texinfo (it’s pretty nice compared to writing in Docbook or HTML, IMO), and very good for version-controlled collaboration, since it’s just text.

For an example, here’s what the help source text looks like:

http://bibdesk.svn.sourceforge.net/viewvc/bibdesk/trunk/bibdesk/English.lproj/BibDesk%20Help/bibdesk.texi?view=markup

The init file and other stuff is here: http://bibdesk.svn.sourceforge.net/viewvc/bibdesk/trunk/bibdesk/BibDesk%20Help/

If anyone’s curious about it, feel free to ask me questions here. I’ll try to remember how it works.

Each post got plenty of responses. Dissenters have a wide variety of reasons for why it’s no big deal, ranging from “tomorrows tinkerers will just play with different technology, like bio-mecha” (fascinating!), to a lot of people saying, essentially, “Just don’t buy the appliance if you want a computer” (obvious!).

Others have made a solid point that the iPad is the next big computing paradigm. Steven Frank calls it a “New World” device. I can’t help but agree, and of course powerful devices that empower instead of confuse the user are a good thing. Replacing most of the world’s overcomplicated, fussy laptops with focused and reliable devices is a good thing.

Of course, general purpose, hackable computers are not really going away, not soon. Even if everyone uses an iPad for personal stuff and a Chrome OS netbook to access private cloud services for business work, there will still be a need for workstations, and I hope the people building complete personal systems out of Free Software don’t give up.

However, in a response to comments on his post, Mark Pilgrim made a gloomy prediction: “People haven’t figured it out yet, but Mac OS X is on its last legs. By 2015, Apple will make appliances and developer add-ons. Not general purpose computing devices.”

If you ask me, this is the real problem.

The problem is that hackable computers that I want to use could very well be fading out. Maybe Mark’s overstating things, but I would not be surprised to see the Mac, and OS X, as a relatively low priority for Apple in the near future. Design and development effort and creativity will naturally go increasingly toward the more profitable platform – the one making computing finally pleasant for the normal person.

I’m worried that this will happen for third-party developers too. I’m not the only one. Back in 2002, Brent Simmons described developing user code for the Mac as “the show”. Is there any doubt that Apple’s mobile OS is “the show” now?

Where does that leave the rest of us who still have to or want to use a more powerful platform?

I love it when I can guess how to do something new in a program. Skim just did this for me – I needed to figure out how big the rectangle of text in a paper I’m working on is, in inches. I looked for rulers, and then decided I’d just see if I get any size feedback when I make a rectangular selection. Turns out there’s a nice feedback status line in the bottom right – clicking toggles between measurement in pts and in inches.

I like how this solves my problem without adding a lot of new UI for measurement – no rulers, no extra tool to measure length.