OddThinking

The Rational 1000 didn’t have a Save command. Well, it did, but it wasn’t called Save, and I didn’t really need it, and it didn’t really Save. Well I did need it once, but… well let me start at the beginning.

When you first created a file on the Rational OS, before you started editing you were asked to provide a file name. Once you were happy with your edits you could hit the Commit button to indicate the the changes should be kept.

The Commit button was like a Save button, but it didn’t write it immediately to a permanent store. Instead, it was put into an intermediate cache where it would be written to disk as part of a batched operation in the next “Snapshot” operation. The Snapshot operations occurred automatically every 30 minutes, and would cause the machine to grind to a halt for anywhere from 2-10 seconds. In reality, most of the Snapshots would happen while you didn’t happen to be typing, and you wouldn’t notice them, but it seemed like every snapshot occurred when you were typing away madly, and they were an annoying distraction.

Several of the other operations (e.g. semanticizing) did an implicit Commit of the file. If you were writing code, you would perform dozens of these operations each hour. The practical effect was that the Save operation became both fast and implicit. It just happened, and you forgot about the issue. The main downside was the annoying Snapshot delays.

Of course, there is a risk to this approach, and it struck me hard several months into the usage of the Rational. I had been gradually lulled into ignoring the need to do an explicit Commit command; it was implicitly done every time the code was parsed.

I set out one morning to do some substantial rearrangement of some code – what we would now call “refactoring”. I was breaking up an overly complex package into a number of smaller, simpler packages. I had been working all day cutting and pasting code, admiring how much better it looked in its new position. Of course, at no point was the code ready to parse – it was still in fragments, so at no point did I run any of the commands that did an implicit Commit.

You’ve already seen it coming. The computer crashed around 3pm, and everything that hadn’t been committed by the time of the most recent Snapshot was lost. My day’s work was lost.

I became obsessed with that Commit button for months afterwards; sometimes pressing it repeatedly for good luck, even if I hadn’t made any changes.