6
$\begingroup$

What would the world, and more specifically, productivity on modern computers, be like if Undo (a.k.a. Ctrl-Z) functionality has never been and will never be invented? To clarify: there is no functionality on a modern-day computer that lets you undo and/or redo your action, in no software whatsoever. You can still manually negate your actions, e.g. you can still delete something you just typed, but you'd have to do it all manually.

Would it just be a minor dent in productivity? Or would there be places/tasks in which this would be a major problem? Are there particular tasks that could almost never be performed without Undo?

P.S. This question, admittedly less inspiring questions than most around here, arises from the claim of a friend of mine that Ctrl-Z is the best invention in computing since the computer itself.

$\endgroup$
  • 2
    $\begingroup$ Would people not just save every 30 seconds and reload if something bad happens? (i.e. implement undo manually). $\endgroup$ – Tim B Dec 6 '14 at 19:12
  • 3
    $\begingroup$ @TimB This might not be practical when you have large files with a long saving delay. If it takes 3 minutes to save, it's not a good solution. $\endgroup$ – Vincent Dec 6 '14 at 20:29
  • $\begingroup$ IMO, it wouldn't be such a big deal. Think about your own work; how often do you really use ctrl-Z ? And when you do, how often is it the same amount of time to hit ctrl-backspace ? $\endgroup$ – Shokhet Dec 8 '14 at 1:33
  • 3
    $\begingroup$ This makes me think of another question: What would the world be like with a real-life Ctrl-Z? : Car crash? -> Undo. $\endgroup$ – mouviciel Dec 8 '14 at 8:16
  • 9
    $\begingroup$ See: Typewriter. $\endgroup$ – Mark Dec 9 '14 at 1:40
8
$\begingroup$

The original WordStar 1.0 (word processor) did not have undo. People still used them in offices. And they were still productive. It had delete and backspace. It's biggest draw in the office was that employees always produced perfect documents and they can proofread before printing (a big thing then)

https://www.youtube.com/watch?v=lS8RWGqUWPE

Book authors loved Wordstar no more messing around for liquid paper when you make mistakes with your typewriter.

People found ways around the limitation of not having undo, like making multiple copies of a file. One of the biggest request was undo, so the next version I think had undo. So yes undo is important to people.

extra note: Game of Thrones was written on WordStar 4

http://www.theverge.com/2014/5/14/5716232/george-r-r-martin-uses-dos-wordstar-to-write

$\endgroup$
5
$\begingroup$

IMHO, your friend is right. Civ V has no undo that I know, and thus the most common reason for a unit dying, challenged only by the automation AI being broken, is clicking the wrong hex. A game should not really be about making sure you do not click the wrong spot, and neither should any other application.

That said, defining the effect is elusive, many games have no undo and instead use save games, operating systems use "trash cans", restore points and backups instead of multi-level undo. Databases use transactions and backups. And there is no convincing reason this makes any of these less "productive" or usable.

By comparing applications that have undo to the ones that do not, the main benefit seems to be that you can do something without needing to know if it will work out or precisely how to do it by stepwise experimentation of the problem. This would be a major pain if you had to do the saves, versioning, and reverting of changes manually. Maybe this would qualify as something that could almost never be performed without Undo? Without undo the "granularity of experimentation" would be much coarser and consequently the common process of stepwise refinement would suffer, probably to the point of "major issue". Another "major issue" would be that learning to use complex interfaces would take much longer.

As said the total effect is elusive, but anyone who does "fiddly" tasks that benefit from stepwise refinement such as design or editing or has to use "fiddly" interfaces such the aforementioned Civ V or, more relevant to your question, most Adobe applications will approve of the sentiment your friend expressed. Undo might not be the most useful invention, but it must be one of the most appreciated.

I'd say the dent would be more creativity than productivity. Undo doesn't really allow doing more, but it is a big help with doing better. This probably does help productivity in the long run, but it is the indirect accumulated effect of things being just a little bit better and usable, not a direct effect you can see at any particular task.

$\endgroup$
5
$\begingroup$

P.S. This question, admittedly less inspiring questions than most around here, arises from the claim of a friend of mine that Ctrl-Z is the best invention in computing since the computer itself.

I'm tempted to point out that Ctrl-Z, while commonly used for an "undo" feature, is just a keyboard shortcut. Back in the CP/M and later the DOS days, Ctrl-Z (or more accurately character 0x1A, often displayed as the bigram ^Z) was often use to indicate end of file in text files and input. Not quite the same thing!

That said, there seems to be two aspects to your question: what could cause computer software to never gain "undo" features, and what would using that software be like?

What could cause computer software to never gain "undo" features?

One possibility that I can see would be if computer memory (and storage) was very expensive. Keeping track of several states and allowing you to undo to work your way back through those states requires memory of some kind. The exact amount of memory required and the memory speed required depends on the type of data you are working with, how efficiently the changes themselves can be represented and how fast you need the undo feature to be to the user; all these are going to be different for different types of applications. A bitmap graphics editor is going to need a lot more and likely faster memory for a usable undo feature than a plain text editor, for example. A specialized financial application might be able to make do with storing only a few small pieces of information and recomputing everything else on undo/redo, if memory is scarce but computing resources are relatively plentiful. Or you could simply re-run any computations based on corrected input, discarding any previous results; this appears likely to have been the approach taken by early computers, which simply did not even have persistent storage (although they quickly followed, even paper tape readers for use with computers were a later invention).

If computer memory is very expensive, then you are going to want to conserve it as much as you possibly can, because any memory used for "undo" state data is going to be memory you cannot use for useful current state. And the more memory your program requires to run, the less people are going to be willing to buy and run your program. Hence, memory-hungry features will be at a disadvantage. Since undo requires both code and data, and potentially lots of particularly data, such a feature would be at a disadvantage. This doesn't necessarily mean "undo" features would never be invented -- someone, somewhere, would almost certainly start thinking "man, I really wish I could get back what I had two minutes ago!" -- but their use and perhaps even availability would be restricted to niche use cases and applications.

What would using software without "undo" features be like?

You would most likely focus on fixing any mistakes in place, rather than undoing back to a previous state and applying new changes from there. This is easier for some types of software than with others. For example, with some sort of text editor, fixing in place is relatively simple. (Yes, this includes programming, because most modern forms of programming at the core is about manipulating text representations of programs.) With advanced graphics or design, fixing in place is going to be more involved, but still certainly possible. (Lots of great art has been produced on media which does not allow any type of undo other than fixing in place.)

Which leads us to that you would think before you leap. You would probably spend more time considering the impacts of any change, because you would be reluctant to have to fix any mistake you make.

Saving regularly when you have something that you are happy with and keeping several revisions stored would likely be a common use pattern, although that also runs up against memory and storage requirements plus the problem of how long the fresh save itself takes. But it would give the user a limited form of undo functionality on computers that don't natively support it.

Using such a computer would likely be similar to how one uses a typewriter or paint canvas: focus on making the initial revision as good as possible, then either live with mistakes being present, or correct them in place and perhaps make a new "corrected" copy for distribution.

For a perhaps extreme example: does your (computer-controlled) washing machine have an undo feature? Mine doesn't. It does have an abort feature (so I can stop the washing program at an arbitrary point), but it doesn't have undo (no built-in way to make the laundry dirty again).

$\endgroup$
2
$\begingroup$

Undo is an incredible tool for software developers. It's not just for removing a couple words you didn't mean to write, it can easily bring you back to the last almost working point before you really started messing with it. Let's just say I would have to have a very different philosophy about how I perform my work if it was unavailable, largely making back-ups frequently before making changes and slowing me down having to always remember and think about that and then trying to find the right version to go back to.

However, for Undo to never have been or will be invented, the only way I could see that as even a remote possibility is if the number of mistakes we want to correct are so few it is just as easy to fix them. Either we are near perfect in our use of computers or we just don't care about the mistakes.

$\endgroup$
  • $\begingroup$ My answer really should have mentioned that software development is heavy in "design and editing", benefits greatly, and that the greatest increase in productivity probably comes from the improved quality of all software you use. I was thinking about that constantly, but forgot to write it down. I guess I could edit. $\endgroup$ – Ville Niemi Dec 8 '14 at 9:06
  • $\begingroup$ A large proportion of developers use git, a version control tool that essentially streamlines the process of making "backup" copies of source code and working with these copies. For me, undo is a convenience; being able to compare my current version with old versions is the critical feature. $\endgroup$ – Tanner Swett Apr 9 '15 at 16:17
2
$\begingroup$

Fun question!

I am going to tackle it from point of view and offer several plausible scenarios from that:

No Undo at all:

1) Computers did not make it to "personal": Did the machine for cracking Enigma code had Undo? I doubt it. Did ENIAC had undo? Double doubt it. Correct me, if I am wrong, but I think that because we discovered transistor, it allowed computers to be smaller. Imagine a world where we did not discover transistor. As you can see, it would still allow computers to appear, but they would remain big, bulky and ... without undo functionality.

Almost no Undo:

2) Ridiculous software patent owned by patent troll company: The big names, as we know them now, started from garage. (Yes, both Microsoft and Apple). Imagine that PaTrollCo* is buying the SW company which came with "Undo" first and patents it.

Since then, the PaTrollCo sells this patent for ridiculous amount of money, actually causing that almost no one is using this functionality

* Not actual name, all resemblance with dead, living or other companies is purely fictional. Do not sue me, please

3) Bill Gates was right

640K ought to be enough for anybody*

Yes, I know, that Bill gates did not actually say it. But lets say he did say it, and actually he was right. If anything goes above 640K of RAM, it causes Stack Overflow and crashes (pun in link intended). And no one knows why

Obviously, this is then "engineering issue" and people would be hacking their systems to be able to work with such limitations. Great example of what can be done with known set of limitations, are consoles. If you compare first game for given gaming console, and the last one, you will be amazed what power can be "juiced out" from given console. So this could in theory provide Undo to computers, but it would be pricy feature

* Dear lawyers, this sentence was said by alternate Bill Gates in alternate Universe. If you want to sue me for this, please do it in alternate reality. Thank you

4) We never realised it can be done "Oh shoot, I accidentally made the whole spreadsheet red"

"Well, you will have to work overtime to fix it."

"I wonder if there could be better way to..."

"No, there is not."

Obviously the least plausible explanation of the whole situation. We know people like to hack their machines, and since the whole free software community is around, I would not recommend going this way

Way around:

4-eye principle: Even now, in our glorious* current universe, there are processes which cannot be undone. One of ways around it is to require second person to confirm such action before that action goes live.

* Subjective feelings of "glorious" can vary. Please do not sue me.

$\endgroup$
  • $\begingroup$ "No Undo at all: 1) Computers did not make it to "personal"". Hogwash. PCs existed long before Undo features were added to software. $\endgroup$ – RonJohn Aug 24 '18 at 19:35
  • $\begingroup$ Thats exactly what I am saying in point number one :) $\endgroup$ – Pavel Janicek Aug 25 '18 at 10:04
  • $\begingroup$ I don't see how Computers did not make it to "personal" means that PCs (Personal Computers) existed. $\endgroup$ – RonJohn Aug 25 '18 at 14:13
  • $\begingroup$ @RonJohn so you are saying that Personal computers existed before ENIAC? Please do read my answer point 1 again. That hypothetical situation means that in alternate history the personal computers never existed because transistor was not invented... Also, if you claim that personal computers did not have undo feature, please back that claim by a source $\endgroup$ – Pavel Janicek Aug 25 '18 at 15:48
  • $\begingroup$ Maybe the title of option #1 is phrased ambiguously. But I see now. In that case, there would be no need for Undo, since computers would remain batch machines. $\endgroup$ – RonJohn Aug 25 '18 at 17:54
1
$\begingroup$

We still don't have undo. Oh sure you can reverse a few trivial changes to a word doc. But consider.

You are a sys admin. You have an urgent situation caused by a disk getting full. You find that a looping system has filled /var/log/blah with junk. You are typing rm -rf /var when the lights flicker. You look at your screen and realize with horror that the cursor is now on the next line. The mains spike caused your system to see an "enter" pressed. All of /var is gone. Pray you have good backups and that your story about the mains spike is believed.

Or if that is too technical imagine that you have just composed an e-mail warning one of your new colleagues about a particularly obnoxious but important customer. He really p***ed you off yesterday so you do not hold back. In fact you exaggerate somewhat. You press send. And then realize that somehow you have sent it to everyone in your address book. Career over?

At least it's unlikely that either of these kill anybody. I'll leave the stories about radiotherapy machines and nuclear reactors to your imagination. But do Google the phrase "always mount a scratch monkey".

$\endgroup$
0
$\begingroup$

The forces that created undo would create undo sooner or later. Let's call it much later. You see, Undo didn't work well in the early days because it was constrained by memory.

The forces that created source control have existed since programs existed. The source control tools have existed since they could reasonably exist in software. Big sprawling branching source trees would exist, and the lack of an undo would push their development harder and faster.

Something rather like svn would appear in the 70s, and that's only the beginning. Programmers would learn to commit their work early and often, using source control as a proxy for the missing undo. But there's more. With this frequent commit rate, the forces that created git would be magnified so great that git becomes worthwhile to build about as soon as the internet exists. But its form is different; with all these local commits, history compression on push/merge becomes the normal operation. There is no reason to see the developers local commits, and bisect and other tools go smack running into them, so we don't keep them that long. (There's a huge philosophy thing along these lines but we need not go there.)

Corporate document control would be bootstrapped along much similar lines pretty quickly because the overriding need is so great and process heavy document control just doesn't cut it. Let us say they just use source control with a dumber front end.

With the explosion of disk space in the 2000s and the explosion of memory in the 2010s, undo becomes inevitable, but it takes on a stigma. It screams to those who know "I lack the ability to use source control." The primitiveness of the tool in comparison to the source control/document control tool would result in there always being the elite who switch to the more powerful/sharper programmer tools that never developed such a crutch.

$\endgroup$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.