That’s it, we’re quitting

The “Quit” command in applications today is a relic from the days when the original Macintosh had no hard disk and couldn’t multitask. Modern applications have made this command increasingly annoying. Fortunately, though, modern PCs have also made it increasingly unnecessary. Mobile operating systems have, for the most part, eliminated the “Quit” command completely. In Ubuntu, the messaging and sound menus will help us do the same.

A compromise that got out of hand

It’s easy to forget just how much more powerful personal computers are today, compared with the machines on which some of our user interface conventions began.

In 1983, the Apple Lisa had a 5 megahertz processor, 1 megabyte of memory and two floppy drives — but failed largely because it was too expensive and slow. So the first Macintosh in 1984 instead used an 8 megahertz processor, only 128 kilobytes — kilobytes! — of memory, and one 400 KB floppy drive.

Implementing a multi-application graphical user interface on that original Macintosh required many design tradeoffs. Most importantly, while the Lisa could multitask, the Macintosh just didn’t have enough memory. Except for a few small accessories, only one application could run at a time.

This raised an interesting problem. If you had an application open, and you closed the only document you had open in that application, what should happen? To open a document belonging to a different application, you’d need to go back to the file manager (which was the main application launcher back then), and that would require unloading the application. But if the next document you wanted belonged to the same application, unloading and then reloading that application (from a floppy disk, remember) would be an annoying wait.

So, the Mac designers made two decisions. First, they introduced a way to open a file within the same application, without going back to the file manager: the Open File dialog. And second, they required users to specify manually when an application should remove itself from memory to make way for another one — by invoking a “Quit” command.

This was a reasonable, if awkward, compromise. As the years went by, though, something weird happened. The Amiga copied both these ideas, and then so did Windows, and OS/2, and KDE, and Gnome, and many other environments — even though they could all multitask and (except for early Amigas) used hard disks. It was a classic case of cargo-culting.

To be fair, Open dialogs eventually became more efficient than file managers for the specific task of opening files. But “Quit” (which Windows called “Exit”) became less and less relevant. Mac OS X moved the “Quit” menu item from the “File” menu into the junk drawer that is the application menu. But quitting has remained a basic part of how Mac applications present themselves, and it has persisted for many applications in Windows and Ubuntu as well.

A few behemoth applications, such as LibreOffice and Gimp, still keep “Quit” separate from “Close” for the original reason — to save you from having to wait for the application to relaunch after closing its only document. But that is fixable, and all other applications have become fast enough that they don’t need it any more. After all, they’re running on hardware that is hundreds of times faster than it was in 1984.

People who have been using computers for a long time sometimes get a sense of reassurance from the idea of controlling application unloading themselves. Meanwhile, though, the presence of “Quit” has been getting confusing and even a bit destructive.

The problems with “Quit”

Most obviously, there is a problem with Web browsers. First, people have gotten more comfortable with the idea of having multiple Web sites open at the same time. Second, Web applications have become more common and more stateful. And third, since 2003, Web browsers have competed partly on how minimalist their interfaces can be — which has made the browsers less and less obvious as applications themselves.

As a result, the effect of “Quit” in a browser is now bizarre. For example, imagine that you have windows open for Amazon, Banshee, Calculator, eBay, Empathy, Facebook, Gmail, and Shotwell. What happens if you choose “Quit” in the Gmail window? Gmail quits, but Amazon, eBay, and Facebook quit too, while Banshee, Calculator, Empathy, and Shotwell stay open. How much sense does that make? Not much.

Browser designers have tried various hacks to lessen this problem. Some browsers ignore the standard Ctrl Q keyboard shortcut for “Quit”, because of the damage it can cause. Some put up a confirmation alert, asking you if you’re sure you want to quit. And some offer, in that confirmation alert, to remember your windows and tabs for next time you launch the browser.

The existence of a confirmation alert is a fairly reliable clue that the original design is broken. And that’s true in this case: none of those workarounds make it obvious, ahead of time, which of your applications are about to disappear. And even if a browser restores all the pages you had open, usually it has still lost any work you were doing in those pages. In Ubuntu, the Epiphany browser avoids the problem much more simply: by not having a “Quit” command at all.

It’s not just Web browsers, though. The same problem exists in any application that has windows for apparently distinct tasks.

For example, if you have a presentation open in KPresenter, and a spreadsheet open in KSpread, and you choose “Quit” in KSpread, the spreadsheet closes. But if you have the same presentation open in LibreOffice Impress, and the same spreadsheet open in LibreOffice Calc, and you chose “Exit” in Impress, the presentation closes, and — surprise! — the spreadsheet closes too. How much sense does that make? None whatsoever.

KPresenter and KSpread are coded as separate applications, so they quit separately. LibreOffice Impress and Calc happen to be coded as a single application, so they quit together. But why should you have to know that engineering detail? On 21st-century computers, it’s irrelevant.

Finally, “Quit” is confusing for any application that can do useful things in the background without windows open. A long-standing example is the file manager, which typically controls the desktop as long as you are logged in, and so doesn’t have a “Quit” function. A more recent example is the Mac App Store, which — like Ubuntu Software Center before it — continues downloading and installing applications when its window is closed. Surprisingly, though, the Mac App Store continues downloading and installing applications even after you “Quit” it. In Ubuntu Software Center we avoided that weirdness by not having a “Quit” command in the first place.

In other cases, though, the behavior needs to be more flexible. You might, or might not, want to be notified of new e-mail messages when your mail client isn’t open. You might, or might not, want to receive incoming chat messages or calls when your IM client isn’t open. And you might, or might not, want to keep playing music even when the music player isn’t open. In these applications there is at least a useful distinction between “Close” and “Quit”. Unfortunately, the result is that “Quit” is being used to mean several quite different and non-obvious things: “don’t check for messages any more”, “go offline”, “stop music playback”, and so on. A single term probably isn’t a good presentation for all these things.

In summary, then, “Quit” is more confusing than useful. For many applications, it can be either removed altogether, or changed to the more straightforward “Close” if that item isn’t present already. But for applications that run configurable things in the background, the design is a little more complex. Fortunately in Ubuntu, we have some elements waiting to help out: the messaging menu, the me menu, and the sound menu. (It’s almost like we’ve been planning it.)

Messaging

Since Ubuntu 10.04, Ubuntu has had a messaging menu, which shows incoming messages from humans, as received by any application that integrates with it. (It’s been great to see Thunderbird integrating with the messaging menu, for example.) Ubuntu also has a “me” menu, which — among other things — lets you set instant messaging status, for any IM or VoIP application that integrates with it. It’s possible the structure of these menus will change in the future. But the basic idea will stay the same.

One awkward detail has been that if you have used the me menu to go offline for instant messaging, you can’t use it to go online again. Last week, Ken VanDine fixed that problem — which means that for any IM application that integrates with the menu, it’s no longer necessary for it to have a “Quit” item. If you want to go offline, you can do that from the global menu. And if you want to close the program’s contact list, you can do that without affecting your online status. The functions will no longer need to be tied to each other in unpredictable ways — they will be completely independent.

For e-mail and similar messaging clients, things are a little trickier. At the moment, these applications typically stop checking for messages when their window is closed. However, many people apparently want these functions to be independent too — as shown by the variety of separate mail notifiers available in Ubuntu.

The engineering solution here is for messaging clients to split out the code that checks for new messages, so that it can optionally run even while the rest of the application is not. Gwibber already does this, for example.

Music

There are two main kinds of media player application. For standalone players like Totem and VLC, which mainly play individual files, the behavior when you close the window is fairly straightforward: the media should stop playing, just like a game or Web page would.

For jukebox-like players like Rhythmbox and Banshee, though, what should happen when you close their window has long been a source of debate. With Ubuntu’s sound menu, we have a chance to resolve it clearly.

The basic design principle of the sound menu is that in a multi-window environment, it’s reasonable to want to control a jukebox-type player quickly without its window being open, and that a menu is a good way to present that. Again, it’s possible that the exact presentation will change in future, but the basic idea will stay the same. We’re delighted that thanks to the Mpris standard, Amarok, Banshee, Clementine, Exaile, MPD, Rhythmbox, Spotify, Symphony, and Xnoise will all integrate with the sound menu in Ubuntu 11.04.

Having a separate quick-access interface reinforces the basic idea that whether a jukebox window is open, and whether music is playing, are completely independent things. You can close the jukebox window without interrupting playback. And you can start or stop playback without opening a window.

Implementing that much has been easy enough for our friends working on Banshee, for example. But it introduces a new issue: If you want to start music playing from the sound menu, you can’t be expected to know or care whether the player is already running. So in Ubuntu 11.04, the sound menu will show the Play button even for registered players that aren’t running. If you choose Play, the player will launch and then start playing.

If a player takes a while to launch — because it scans a database of media each time it launches, for example — making this a smooth experience will be a challenge. There are several possible solutions, though, depending on the player. For example, it could remember which track it was playing when it was last running, and postpone any database scanning if it has been launched for the express purpose of playing a particular track. Or it could even keep running in the background for a couple minutes after you stop playback with no windows open, just in case you’re going to start playback again.

Always be closing

Phone and tablet operating systems, such as Android and iOS, have abolished the ideas of “quitting” or even “closing” applications altogether. In Ubuntu, running on screens large enough (and with pointing devices precise enough) for multiple windows, “Close” remains a very useful idea. But with a little effort, we can reduce frustration and simplify Ubuntu overall, by making “Quit” something that humans no longer have to think about. Let’s stop being quitters, and start being closers.