Ctrl-Z-the-world

Who among us hasn’t wished we could take back something we’ve done? A thoughtless comment met with stunned silence. Eyes widen, realization hits. Maybe you clap a hand over your mouth. Or maybe you hope to pull the words out of people’s memories with an almost unconscious move: thumb and forefinger hitting the invisible keyboard, to return to the pristine state of ten seconds prior. Ctrl-Z. Undo. 

Since humankind has committed our thoughts to the record, we’ve also wanted to undo some of those thoughts. And we’ve made strides. Whereas Gutenberg had to deal with someone putting  up the wrong text block into the printing press, by the latter half of the 20th century we could fix our words with Wite-Out or the electric typewriter’s lift-off tape (not to mention the erasers that have topped our pencils for over 165 years). But the digital Undo — whether granted with a little U-turn of an arrow, a shake of an iPhone, or the classic Ctrl-Z key binding — is arguably the most transformative. 

Undo — at its most basic, a function reversing the most recent operation — is more than a convenience: its emergence and eventual ubiquity have shaped both the evolution of our technological systems and our behavior. “This belief that your actions are reversible, or at least not catastrophic in their action, changes the way you view them,” says computer scientist Alan Dix, a professor emeritus at Cardiff Metropolitan and Swansea Universities who has written extensively about human-computer interaction. 

The concept of Undo unlocks a surprisingly existential thought experiment on the branching nature of decisions, the implications of choice, and the very nature of our existence in the supposition of linear time. And it dates back to the start of computing itself.

“ As soon as we got into interactive computing — where you did stuff on the computer — people thought that it would be great to be able to undo what they did,” says Brad Myers, who teaches computer science and directs the Human-Computer Interaction Institute at Carnegie Mellon University.

In his book Pick, Click, Flick! The Story of Interaction Techniques, Myers tracked the first recorded discussion of Undo to programming pioneer Warren Teitelman’s 1966 PhD thesis at the Massachusetts Institute of Technology, which explored the function’s theoretical possibility. The first implementation came two years later with programmer Andries van Dam’s FRESS, a.k.a. the File Retrieval and Editing SyStem, a widely embraced early hypertext system. FRESS allowed users to link and collaborate on digital documents in the ways that we all now take for granted; it was the first computer system to feature Undo capabilities. Teitelman, who had laid the theoretical groundwork, went on to work at Xerox PARC (the Palo Alto research center that pioneered modern computing breakthroughs from Ethernet to the graphical user interface), and later incorporated early Undo function into the programming language there. (While that particular programming language was later replaced, the core concepts of Undo remained.)  

By the 1970s, Undo was an expected part of academic and industry research systems; by the 1980s, it made it onto home computer programs. Accessing Undo on early systems involved a mouse click, or a designated Undo button on a keyboard. The actual Ctrl-Z shortcut is attributed to Larry Tesler, who made it part of his work on the seminal-yet-doomed Apple Lisa — the first mass-market personal computer with a graphical user interface — in 1983.

Undo is now a basic tenet of computing design. It’s in the original Macintosh Human Interface Guidelines from 1987, one of the 8 Golden Rules of Interface Design that pioneering computer scientist Ben Shneiderman first laid down in 1985, and one of human-computer interaction innovator Jakob Nielsen’s 10 heuristics for evaluating the usability of interfaces. It’s now so commonplace we hardly think about what we’re undoing. 

While Undo is a computer function, from the user’s point of view it’s also an intention — to recover a past situation. This is also the way we operate in the world. Say you take a wrong turn in your car. GPS systems will fix this by engaging in what’s called forward recovery — instead of making you U-turn back to the site of the initial wrong turn (as happened in the earlier models), they look at where you are, where you want to go, and re-plot the best route to get you to the intended destination.

Forward recovery is a powerful tool, and often it works. More importantly, it’s the only form of repair that’s actually available to us as humans tripping through linear time. 

But with Undo, we can engage in backwards recovery — instead of figuring the best way forward from an error, we go back and un-make it. 

The simplest version, called the Single-Level Undo model, can only undo the latest operation. Hit Undo once, the last operation is undone. Hit it a second time, and in a sense it “Undoes the Undo” — restoring the original operation. The implementation and scope of early Undo was somewhat limited by memory, which makes sense — in order to go back to a previous state, you’ve got to keep track of it. 

The system we now take for granted is what’s known as Multi-Level Undo; it also emerged in the 1980s and became more ubiquitous as memory capacity of early computers increased. Each subsequent Undo takes the user back further and further in what’s called the undo stack, or command history, allowing you to backtrack on the path you’ve gone down. It’s also coded to take into account pacing and spacing, consolidating keystrokes and deletions in succession, so that actions are chunked into words or labeled segments: The Undo path exists by words and sections, rather than a tedious letter-by-letter. The effect, Dix says, is effectively “we’re just gonna roll back time.” 

That ability to essentially roll back time — to a certain extent anyway — draws into relief how we think about permanence and choice. Multi-Level Undo allows you to roll back time and roll it forward again, but only to a certain point. “As soon as you do anything, you solidify where you were in the past,” explains Dix. “You fix where you are… you can’t then redo what you didn’t do before.” 

Say you were typing out a thank you after talking to Dix, and wrote, “That was a really helpful conversation, Albert.” And then whoops, realized you meant to type Alan (happens), hit Ctrl-Z to remove Albert, and enter Alan instead. If you hit Ctrl-Z again, you’ll undo the line about a helpful conversation. There’s no way to get Albert back, unless you enter it manually — the undo takes you back to the delta, but not back down the previous fork. And while there may be times you want to remember Albert, by and large an Undo function that maintains every potential path creates  ”such a bushy tree that nobody could find anything,” said CMU’s Brad Myers. “It was pretty useless.” The hard stop of an endpoint (or is it the beginning point?) is an intentional limitation that forces the user to make a new decision only from certain junctures in the work. It tidies the chain of thought by encouraging the user to retrace (and thus rethink) linearly, providing one specific, narrow channel for reiterating. Whether the user realizes it or not, it essentially keeps the decision-making organized. 

The alternatives have proved unwieldy. The Emacs text editor, an app originating at MIT in the 1970s that has been widely used to write code, featured standard multi-level Undo. Some programmers coded Undo visualizers, plug-ins where users could see the different paths taken (i.e., the Alberts accidentally entered along the path to Alan), often represented with an indented sub-history for each explored branch, which allowed programmers to basically read down the spine of the indentations to return to various forks taken. But Jim Blandy, a software developer at Mozilla who used to maintain the Emacs text editor, stresses these were never widely used extensions, more like “random things flying around in the 1990s.” Because this entire representation of all the paths taken, while comprehensive and occasionally helpful, could create what Brad Myers called “a user interface problem” — counter to the task of actually getting things done.

“Do I really want the entire recapitulated keystroke by keystroke history of a doc?” asked Blandy. “As a human being, my success depends on my ability to forget things.”

For the most part, users who are civilians and not software engineers and do want to go back down overwritten paths have to reach into the version history, which is a slightly different animal — borrowing from a version of the past rather than journeying back to it. Version history’s “retrieval” nature, unlike the step-by-step retracing of an Undo, adds a layer of removal often left to chance: maybe the last autosave was minutes ago, maybe it was a day. Ideas and potential paths taken might be lost in the time gaps, a disruption that can feel welcome — if you want to go all the way back to a world before specific paths were taken, or want to think about potential retreads in a more disconnected way. But if what you need is somewhere within those threads — well, that’s less helpful. 

To simply hit Undo an unholy number of times in a row animates the results of various decision trees in a way that can lead even a casual word processor user down a trippy meditation: why this word over that word, what if I hadn’t gone down this path, why going back 12 steps in a train of thought can reveal the best way forward.  ”The philosophical issues around it are really interesting,” laughed Alan Dix. “[In computing] and yes, in life. And actually they do overlap.”  

The presence of Undo has big impacts. For the casual, everyday user, this flexibility allows us to spill out our thoughts onto the page, to brainstorm and tinker around. To be creative, and explore, without much in the way of consequence. And for industry architects, it can allow for the creativity that can lead to big ideas. By turning down the temperature of composition, Undo mitigates not just potential breakage but the fear of it. “If you can recover anyway,” says Dix, “it gives you freedom to explore.”

Many argue that it both embodies and enables the sort of technological and ideological exploration that made computing possible in the first place. Being in control has the effect of allowing you to be a little looser. 

“The impermanence of the digital world — the malleability of it, the ability to just shift it around and not worry too much — is absolutely brilliant to enable you to learn rapidly,” Dix says. “Having the Undo function on more complex endeavors allows folks to, for lack of a better term, mess around. Why not play, spill your thoughts onto the virtual page, try different paths?” 

The technology moving our world has capabilities that seemed, until recently, more the stuff of speculative fiction than everyday life. Making the cost of mistakes lower is part of what makes that possible. As we marvel at all that has been done to make our modern world, there’s space to recognize all that has been undone along the way.