Hacker News Reader

I'm confused. All it does is make the "bad" behavior the default, but give you the option to revert it if the original file exists somewhere on disk? That's an improvement?

Versioning (and allowing reverts) is awesome, but changing a decades-old idiom to something that suddenly destroys data is...well, scary, to say the least.

Edit: Someone further down the thread suggested that the function be renamed to "Duplicate and Save". That would totally fix the problem - this is a new interaction mechanism, totally different from what we've all been training on for the last thirty years, and it needs a new name. The feature itself is fine, but hijacking an existing operation's name for it is not cool. It violates the principle of least surprise.

Versioning is always happening. It’s not possible for you to be not able to revert.

Also: “Save as …” is a deprecated feature (basically). You can’t even see it in the menu. There is only a keyboard shortcut for it – for those traditionalists who can’t let go. It’s not going to make the new document model worse (which is a massive improvement over the past) just to keep “Save as …” working.

Documents always save. They never not save. You can easily revert or access versions. You can easily create new versions (for example by clicking “Save” in the menu or by pressing Command+S). You can easily duplicate and immediately rename documents.

I'm not sure there was a way to introduce auto-save while maintaining the "principle of least surprise". I'm astonished, myself. I figured that, thirty years from now, we'd still be losing changes to periodic crashes of unsaved documents rather than force any customer to alter a decades-old workflow.

The problem with "Duplicate and Save" is that it implies that saving is an action that you can take, rather than something which has already happened. As arrrg said, that's not true: in Lion apps, every document which has a name is always saved. There is no longer a state of "changed but not saved".

Change the label to "Duplicate and Save" and us old folks, trained for thirty years to be constantly seeking and pressing "Save" lest we lose everything, will be complaining that there's no way to "Save" without also "Duplicating". Which would not promote understanding, either.

Don't worry, if you and the OP miss the old world of unsaved documents you can always find some old-school applications that preserve the old behavior. Join us Emacs users in the land of hoary UX paradigms! ;)

Wouldn't it still have been better to use a different command name rather than commandeer one that has established expected behavior?

Sure, you can have auto-save without surprising the user. Auto-save to something that isn't the file they opened, and the commit those changes when they invoke "save". The UI itself can show whatever the latest version it has (and offer nifty things like "compare with what's saved"), but the file itself isn't written until the user asks it to be.

I'm not sure what word processing software you've been using for the past decade, but periodic backups and automatic restoration is more or less the norm, now. Heck, even my code editor persists unsaved buffers between sessions.

I think the last time I lost unsaved work in a due to a program crash was probably last millennium. That's the root of my surprise here; there are proven solutions that don't break existing workflows. Why did Apple decide to break them now?

I figured that, thirty years from now, we'd still be losing changes to periodic crashes of unsaved documents rather than force any customer to alter a decades-old workflow.

Huh?

Word and Open Office have been recovering crashed documents, including unnamed, never-saved-documents, for quite a while. When that happens, it is a little confusing since you have to overwrite the existing document with the later version. But it also only occasionally happens whereas I often use the save-as functionality.

I agree that using the Save As command is not a good method for modifying files. However, the correct syntax for this modified should be "Save & Save As."

Here is an analogy one could one make to the current implementation -- you request to be billed later, but instead the full amount is deducted from your bank account now, and you are also sent another bill in the mail a week later, which you pay because you didn't know you already paid for it.

Something makes me think that there are a lot of giant egos at Apple now, making eccentric decisions, and Steve Jobs isn't around to tell them they are stupid.

Or you can hit 'undo'. That's been around about as long as well. And since there's no file dialog, you're aware something is different, and the application is still up and running so you can make changes.

What Apple has done is changed "save as", into "fork a branch". This is progress, mostly.

The real end goal here is for Apple to somehow figure out a way for the average person to have the power of modern version control while still understanding it. This is a good goal, and we should laude Apple for it.

This is not how Git, a truly professional version control system, works. In Git, you start changing files on top of the master branch, then realize you don't want to commit that to master, so you fork (checkout branch) then commit your changes elsewhere. Apple has not only ignored how-many years of simple and effective computer Save As practice. It created a not-invented-here version control system... and, as usual for NIHers of complex algorithms, Apple failed badly.

That is only possible in a distributed version control system. Apple's behavior is more similar to SVN/CVS/etc. And for sure DVCS is better and the future, but modeling their functionality after a system that's been used for decades doesn't quite qualify as NIH syndrome IMO.

That's what I was thinking about. You've got to start somewhere, and this will be accepted by aunt Tilly.

It should be noted that Google Docs also has no Save As. It does have "Make a Copy".

I completely agree. A split second of poor judgement can destroy hours of work. In this case I'm happy to let Apple save me from myself.

Reading the rest of the thread, it looks like Apple is already saving you from yourself by creating a revision each time you save. So, this change just increases the amount of work the user has to do by forcing them to go and revert the last save on the orignal document after doing a Save As.

People using "Save As" frequently don't know that they want a duplicate before they start changing things. Sometimes what I think is going to be a minor change ends up being a major change, and I want to "fork" the document.

Think of it in git terms:

I start a changeset, and after some work, find that the changeset is too big or too unstable or too hard to merge upstream. So, I `stash`, `checkout new-branch`, `stash pop`, `commit` (or just `stash && stash apply`)

This new workflow is effectively: `commit`, `checkout new-branch`. Crap, now my unstable changes are committed to my master, and to fix them and get back to what I was working on, I have to `checkout master`, `reset --hard HEAD^`, `checkout new-branch`.

It's annoying and presumptive. If git did this, there would be rioting in the e-streets.

You don't even need to do git stash before switching to a new branch and nor do you need to do stash pop.

Heh, yeah. I usually end up moving changes to another existing branch that way, but for a new branch you're completely right.

Well, it seems it's been made even more dangerous. Why not remove it, re-label it?

Seems like there would be a better way to save the user from their occasional accidental "Cmd S" than by upending a core expectation of computer behavior since time immemorial. Why not allow the "revert" option when you hit "Cmd S"? Seems like you could keep all the same core functionality and just have a right-click accessible history of every file on disk. Is there an advantage the new system has over that?

The new system does what you suggest. Command-S creates a new "revision" in versions, and you can select "Revert to > Browse all versions" to see all versions of your document. OS X also automatically creates a new version once an hour if there are new changes.

The algorithm is actually a lot quicker to act. Once an hour would be quite useless in many cases (especially power loss).

The saving algorithm happens near-instantly, yes - but what's being referred to is the "versions" that are user-visible. Each time you hit Save, Close, or leave an edited document open for an hour, a "version" made that can be reverted to/seen in Time Machine.

I can't see why we can't have it both ways.

There's actually a very simple solution to this problem: "Save As" before you make any changes at all. Only then, in the new version, start to make your changes. Problem solved.

Pardon my rudeness here but who the hell are you to make a proclamation that "Save As" has always been "dangerous and ridiculous". Did you try that in every major workflow, like mine?

Let me give one example - I sometimes want to read the content of the file (inside its own app), maybe make some changes and then Save As a new version. I do this mostly in MS Word (for Mac and thankfully they haven't gotten rid of Save As yet). We keep different version in different files, especially for our team. Updating the original file by default is simply stupid in my case.

It's dangerous. What if you had pressed Cmd + S before you did Save As (my hands have a reflex, I press Cmd + S so often it annoyed me that NetBeans will actually disable the shortcut and give me the warning bell instead because the file hasn't been changed). Now the original is gone. You really should duplicate the file and then make modifications.

Also, with the new Versions stuff in Lion/Mountain Lion you don't have any extra data leakage. The latest file on disk (depends on the app I guess, but most naive apps that use Versions) will be just that, the latest, unlike Word where retrieving old versions/text is relatively simple and can cause an hotbed of issues...

> It's dangerous. What if you had pressed Cmd + S before you did Save As

Then I press Cmd-Z a few times and save again. It's really not so bad. And in this supposed glorious brave new world of auto-versioning, the old version is still available right? So even if I totally forgot it still wasn't "dangerous", at least any more than the new behavior is so.

So ... after Duplicate hit Cmd + Z a couple of times and fix the issue. You just solved the problem yourself.

As the sibling reply said, in that case I'd go with Cmd+Z. What you just described is a benefit of the versions feature and NOT that of removing "Save As". And I do not need the OS to do the versioning. "Save As" has never ever been dangerous. What you described as danger is the carelessness of saving the edits in the opened file and that has nothing to do with Save As.

Welcome to the new era of client computing. In this computing epoch, we are 100% devoted to making life easier for a hypothetical 105 year old illiterate caveman who just emerged from his cave for the first time to buy a computer.

It may appear that UI designers are just working in ivory towers, pushing arbitrary and capricious changes down upon you. When you find yourself thinking that way, just think of the poor caveman.

Exactly. Now compare to this:

"Treat people as if they were what they ought to be and you help them to become what they are capable of being." -- Johann Wolfgang von Goethe

That is the perfect antithesis to Microsoft, Apple, Google, Facebook, Twitter, the list goes on.

And kids. You'd be surprised to know what kids are capable of only if you talk to them in a matured way. Throw them in the deep end intellectually and be very amazed at how much they can think.