Tuesday, 27 December 2022
Today I was interviewed by Colin Ware of “This Does Not Compute.” CW does retro-computing, which involves resurrecting ancient digital technology. He wanted to talk to me about the Scribe project, which is the subject of a forthcoming video on his YouTube channel.
I was involved in Scribe in the early 1990’s while I worked at Apple. Scribe was, initially at least, an attempt to develop a design for a specialized notebook computer — I think of it now as sort of the great uncle of the iPad. It lacked a keyboard and mouse, and used touch and a stylus as input, and was built on the Mac duo platform (an early mac laptop line). It looked a little like an iPad, except that it was a couple inches thick, five pounds in weight, and ugly.
Over time, Scribe grew into a cross-functional project, with contributions from many teams in Apple’s Advanced Technology Group (ATG), and eventually it got moved to the product track and renamed Penlite, only to be canceled shortly before it shipped. However, at the time I’m writing about, various pieces were ‘owned’ by different teams, and the piece I worked on was owned by the Human Interface Group (HIG), the ATG group that was focused on user interface design. That’s what I’ll talk about here.
Scribe — from my perspective — was driven by two concerns. The practical concern was the handwriting recognition — a key input modality for a tablet computer that lacked a keyboard — was not very good. Or, perhaps I should put it differently: in terms of handwriting recognition technology, what we had access to world-class technology, and its developers were optimistic about making it even better; but, this best-in-the-world recognition technology was not, in our opinion, good enough for ordinary people to use without considerable frustration. So we set out to design a system that would be usable and useful even without recognition technology.
The second concern that drove the design was a more of conceptual one. One of the basic principles of the Macintosh user interface was direct manipulation. People used the Mac by acting on digital media using digital tools: each action they took resulted in something happening on the screen right away. It was all present tense. However, because Scribe was envisioned as a highly portable computer, and because this was long before the days of wireless networks, Scribe would often be without access to printers, email, and other resources that required networks. The solution to this was to design using a different paradigm that complemented direct manipulation: we referred to this as delegation. In delegation, rather than doing something yourself, you instruct a computer (or smart tool, or agent) to do it for you, at some point in the future. Thus, for Scribe, if one took notes, or wrote an email while in a meeting (without network access), it should be possible to tell Scribe (or some part of Scribe) to print the notes or send the email whenever that became possible (i.e. when the computer was hooked back up to a network), without any further involvement on the part of the user.
The Scribe user interface metaphor was the notebook: the screen showed one or more pages of a notebook that one could write on using a stylus or type on using a soft keyboard; along the bottom of the screen was a slide-out drawer that contained tools and commands for operating on the notebook content. The big innovation in Scribe — which was embodied in a series of patents* — was a concept that we referred to as stamps. Stamps were a way of labeling pages, sections, and parts of sections (bit maps), so that they could searched, navigated, or collected into lists. For example, a phone number written on the screen using a stylus would appear to the computer to be just a bit map (i.e. without handwriting recognition); what one could do is drag out a “phone number stamp,” stick it on the page next to the number, and inscribe an outline around the relevant bits that made it up. Later a user might wish to jump from (stamped) phone number to phone number, or view all phone numbers in a list, etc.
In addition to the notebook and its structures, the Scribe also contains interface components for marking data, navigating through data, and for operating on data. Stamps were inspired by the use of symbols in physical notebooks: some users of notebooks (particularly ‘power users’) have personal systems of symbols (e.g. “to do”, “important”) which serve as reminders and markers and as ways of grouping related data. Stamps are important in Scribe because they provide users with a non-textual way of labeling, marking, and searching for data which does not depend on handwriting recognition. The Scribe comes with a default set of stamps, but eventually users will be able to create new stamps, and customize the appearance of existing stamps.
The Scribe Project: The Notebook Interface, Technical Report 91-17, page 11
* It was rare to patent user interface techniques at the time. There was a lot of resistance in… the legal world?… to the idea that software could be patented. Software was though to be like mathematics, which could not be patented. But things were changing — perhaps due to recognition that Xerox Parc’s revolutionary user interface that pioneered the ‘desktop,’ and icons, and pointers, &c., and had no protection whatsoever. (This may be entirely wrong — see a legal history for the facts — but I think this is a good representation of what folks working on software design at the time believed to be the case.)