Rethinking tabs: scalable window management

Tabbed Document Interfaces
(TDIs) have become mainstream nowadays. Did you ever stop and wonder why? Which problem has been solved by introducing them? In this post I will shortly take you through their history, explain why I feel tabs don’t solve the fundamental problem, and why Activity-Based Computing (ABC) might be a more appropriate solution.


Tabs aren’t as recent as most people think. They gained mainstream success once tabbed browsing was introduced (and no, Opera wasn’t the first web browser to do so), but early environments already supported them. Smalltalk (from Xerox PARC) was a programming language, but its windowed GUI is what eventually inspired windowing environments for personal computers.

Windows in Smalltalk

Although not exactly tabs as we know them today, I found it important to show what most likely has been the inspiration for them. Since the tabs are always positioned at the top left of the window, you can imagine quickly running out of horizontal screen space if you were to outline them next to each other. In this sense you can argue these aren’t tabs at all, but just plain windows. This changed when UniPress’s Gosling Emacs moved the tab to the right hand side of the window. Since tabs take up a lot less space vertically, outlining them underneath each other doesn’t take up as much space as outlining them horizontally.

UniPress Gosling Emacs

Don Hopkins presents having more than 10 windows open under HyperTIES, which is an Emacs based authoring tool. The tabs might not behave as they do today, but they solve a similar problem: allowing to have many documents open simultaneously and easily switching between them.

The problem

Having many documents open and switching between them is the task of a window manager, not specific applications. The definition of a window manager according to is:

A part of a window system which arranges windows on a screen. It is responsible for moving and resizing windows, and other such functions common to all applications.

When an application lets the operating system’s window manager handle all its individual windows separately, it has a single document interface (SDI). This approach quickly resulted in cluttered taskbars, which is why multiple document interfaces (MDIs) and tabbed document interfaces (TDIs) became popular. Limitations of the window manager forced applications to address problems which should have been addressed by window managers in the first place. Consequently, many applications are reinventing the wheel.

Remember that taskbar at the bottom of your screen (usually)? Remember what it used to do before it got all modernized and fancy new features were added? When you’d maximize all of your windows you basically had a tabbed interface with the tabs at the bottom. To exemplify I turned off some of the features in my current Windows 7 setup in order to make it resemble what it looked like in Windows 95, as also visualized in the website I have open.


All TDIs and MDIs are doing is moving the problem to a different location. They hide the clutter, only for it to reappear once the application has to manage many open documents itself. This can be useful when the open documents are related to each other, as is often the case in an integrated development environment (IDE), but this definitely isn’t the case for every application. Ironically web browsers are a prime example of applications which often manage unrelated open ‘documents’.

Imagine a desktop where every application decides for itself where to place the ‘close’ button or how to resize it’s window. The exact same thing is currently going on with document management.

Existing solutions

The problem should be handled by the window manager. Applications don’t need to re-implement the same functionality over and over again. This is in line with a principle in software development called ‘Don’t Repeat Yourself’ (DRY) which I hold in high regard. Additionally the same look and feel can be provided across applications. Some steps have been taken towards this end, of which I’ll discuss a few here.

The windows 7 taskbar allows you to group windows together based on the application they belong to. In the screenshot below explorer windows are grouped together in one icon on the taskbar. Usually you know in which application you have a certain document open, so you can easily find it by performing just one extra step.

Windows 7 Taskbar

The problem I see here is the same as mentioned earlier: this simply moves the problem to a different location, and again, documents open in one application aren’t necessarily related to each other contextually. Additionally, even when the taskbar isn’t full, you still need to go through this extra step. (Note: you can configure to only group windows when the taskbar is full.)

Some modern window managers allow you to group windows together manually.

Allowing you to manually organize windows at least gives you the flexibility to create your own context as you see fit, but unfortunately again these approaches don’t scale well.

… which of course begs the question, do they have to scale that well?

I prefer turning this question on its head and looking at it from an opportunistic angle.

Scaling window management

What if window management would be more scalable?

First, some food for thought. Yes, more questions …

  • What is your main reason for closing a window?
  • Why do you organize files?
  • What is your main reason for not deleting a file?
  • In what way do you organize windows?
  • How does file management relate to window management?

A lot of effort goes into setting up the working environment for a particular activity. Wouldn’t it be nice if you were able to ‘store’ this setup and retrieve (or even reuse) it at a later time, just as you are able to store (and reuse) files?

Perhaps the real problem isn’t how we access windows, but how we store them. In order to store and organize these different configurations of windows I proposed using a time line in my thesis.

Laevo Time Line

This is inspired by Activity-Based Computing (ABC) which I wrote about previously, which states that activity should be the central computational unit instead of files and applications. In the context of window management activity can be seen as all the windows needed to achieve a certain goal. It’s up to you to decide what makes up a relevant context, organizing work as you like.

Taking this to the extreme: assume closing a window would be the same as deleting a file. Would you actually ever have to know about the underlying file system again? Window management and file management could become one and the same thing.

Activity-Based Computing

As I’ve mentioned before, I’ve been quite busy, hence the lack of posts over the past few months. A big portion of my time went into developing a prototype user interface for my thesis titled “Managing Activities in Time and Space in an Activity-Based Computing System”. No worries if you don’t have a clue what that means, as I’ll try to do my best to explain the concept in at least 80 pages less than my thesis. In future posts I will disclose the actual prototype and will work towards a stable beta release. Until then – for the curious – you can already access the open source project, but I still need to add instructions on how to compile it in the readme.

UPDATE: Since writing this post, I’ve released an installer for the Alpha version of this prototype, called Laevo.

It came to me as a surprise, that the very same idea I had for my thesis was already being discussed in the 80s, in the early days of Human-Computer Interaction (HCI) over at Xerox PARC. It came to me as a bigger surprise that even though several research departments have been researching the subject over a course of more than 30 years (including a research group over at Apple Computer), the concept still hasn’t caught on in mainstream computing. Activity-Based Computing (ABC) is a new computing paradigm which attempts to address some of the problems with the current paradigm.

Applications: what a terrible term. What a terrible concept. Applications have little to do with the tasks that people are attempting to accomplish. Look. We don’t do word processing; we write letters, or memos, or reports, or notes to ourselves. – Donald A. Norman

Computers are inherently application and document oriented. This is all good and well for simple tasks, such as using a text editor to write a certain document, but is that still a realistic scenario? Computers nowadays make up a big portion of our daily lives. We don’t just write a paper; we look up information on the internet, translate words, use a dictionary, email with contacts for further information, import images, keep track of the deadline when the work needs to be finished, share a draft version, wait for feedback, and later have to reopen our entire working context again to make amendments. A lot of tasks users need to carry out require the use of several applications and documents, simultaneously. Furthermore, we don’t work on just one task at a time. Interruptions can cause us to suspend work on one task and open up other documents/applications required to continue work on another.

Gaaah! I believe this portrays the problem pretty well. Most likely your desktop never looks this bad, but that’s because you tend to close windows you believe you no longer need, exactly to avoid this kind of situation. But at what cost? Think back for a second how often the following thought went through your head: “If only I hadn’t closed that before.”. We lose a lot of time re-initializing a working context which we already set up before, be it one hour, one day, or a month ago. But that’s not all. Computing has become ubiquitous. We don’t just use one device, but several. We don’t keep documents to ourselves either, we share them. Managing applications and documents has become a task in it’s own right; a repetitive, distracting, possibly unnecessary task. I hate unnecessary repetition.

Proponents of Activity-Based Computing feel a lot of this overhead can be eliminated by using activity as the basic computational unit, instead of the file or application. Activity, as defined in activity theory, is seen as “a system of human “doing” whereby a subject works on an object in order to obtain a desired outcome.” This takes into account the entire setting in which the activity takes place; the tools used, the people you communicate and share resources with, the rules governing the community and how work on the activity is divided between people. Activity being a computational unit implies you can open, close, save and manage activities, not too dissimilar as to how you use files now. “The end-user is directly supported by computational activities which can be initiated, suspended, stored, resumed, and shared on any computing device in the infrastructure at any point in time, handed over to other persons, or shared among several persons.”

Humans perform plenty of activities, and thus within existing ABC systems the question arised how to manage them. The concept I explored in my thesis was to provide an overview of activities in time and space, showing when work was done on them and their inner relationships. I argue it is a worthwhile path to explore using a calendar not only to plan your activities, but also to use them. My prototype works towards this integration of activities as a computational unit managed on a calendar. Since the start of this month I started work as a research assistant at the IT University of Copenhagen where I will be researching how ABC can be used by software developers, specifically in software companies with distributed teams, following agile software development. Exciting times are ahead!