Hacker News Reader

Comment by oneeyedpigeon | Hacker News Reader

> it sticks around for 100 years as well

Only if the concept of manual save sticks around that long.

What's the alternative? Autosaves? Did it autosave or did it not? Where did it save it to? Locally or to the cloud? Are the servers available? Does it make clear when they are not? Or worse, does it fail silently if they are not?

Call me old-fashioned but please give me a save button and a file picker ;)

Notably none of the Google Docs cloud apps have any save button or option.

Saving drafts on XenForums is a floppy, even though there is no local save involved.

I'm sure I've seen it in other web contexts.

It took me a very long time to learn not to compulsively hit ctrl-s while using Google docs

Interestingly at one point Google Docs did have a save button, which IIRC didn't actually do anything because it would automatically save. The button was there just to make you feel more confident.

You can see it in the top right corner here: https://sm.pcmag.com/t/pcmag_au/photo/g/google-docs-2010-old...

The button was there just to make you feel more confident.

...and when the autosave inevitably fails, deception like that only serves to anger your users more.

I’m both old and old fashioned, but I’ll take auto-save any day over manual save, especially something that required manual save without support of auto-save.

I’ve lost enough work prior to auto-save being common that I never want to deal with an app that doesn’t somehow save my work pretty frequently.

I like autosaves as well, but as a "I didn't save manually but there is always an autosave"-option. Saving is also a file managment choice.

It really depends on what the app is though, yeah? If I'm in document processing or spreadsheet where you might be working for long periods where a 5min auto-save kicks in could be convenient. However, when I'm writing code that then needs to make rapid changes like updating CSS/JS/etc to be refreshed in browser, then I'm not waiting 5 mins for an autosave. Cmd-S, Cmd-tab, Shift-Cmd-R, boom.

However, Cmd-S is so engrained into the muscle memory, that it's almost instinctual to hit it after every press of a semi-colon.

If I type in rm -rf / and pause for a moment trying to remember if I’m trying to delete /var/log/apache2/ or /usr/local/var/log/apache2/ in a dev environment that auto-executes code when I save it I would strongly prefer that it wait until I manually save.

Which is why I like Autosaves that save a copy. Blender for example autosaves project files into it's own location (and keeps that location clean). If you have a crash you can still go for that autosave file and it works in most cases – but it isn't saved in the folder you are working in.

For certain programs this would be overkill of course, but for others it would be quite cool.

It’s interesting. I use vim which has auto-recovery built in. But I also compulsively save. vim is so much faster than most conventional IDEs that it’s just not worth it for me to look for an alternative to that pattern.

> However, when I'm writing code that then needs to make rapid changes like updating CSS/JS/etc to be refreshed in browser, then I'm not waiting 5 mins for an autosave. Cmd-S, Cmd-tab, Shift-Cmd-R, boom.

VSCode has an autosave that's triggered when you change a file.

I would guess that they swiped that idea (among many of the core features of VSCode) from IntelliJ a good 10 years after they implemented it. Too bad they can't steal more sane ideas from JetBrains' IDEs, I might actually consider switching ;)

I doubt IntelliJ invented the "save on change" feature.

> Too bad they can't steal more sane ideas from JetBrains' IDEs, I might actually consider switching ;)

Not being an IDE is what I like about it, my experiences with JetBrain's IDEs weren't good.

> I’ve lost enough work prior to auto-save being common

And you didn’t develop the habit of compulsive Ctrl-S every five seconds? ;)

multiple ctrl-s' per few characters typed/whenever I stop writing something.

There are reasons for manual save to exist, but I think it's unlikely to stick around as a distinct GUI element which requires an icon.

Experienced users will use a keyboard shortcut, others will rely on autosave or find the File > Save menu. Alas, I suspect the floppy disk icon is doomed.

I have been doing Ctrl+s for most of my life. I type a lot and this is like second breathing. I write a sentence, save. Some pause, save. Looking out the window, save. Its as common as pressing space or enter.

Does it matter? The only thing that matters to the end user is that the changes they made to their document persist. And they should persist by default, not only when the user issues a Save command.

I don't know, I sort of enjoy being able to make changes, see they didn't work/not necessary/etc, and then just closing the document hitting "Don't save" vs hitting undo until returning to last saved state (which was when exactly???). Bonus points for apps that have an actual Revert feature.

Maybe file management will map closer to revision control one day. Autosave would be the equivalent of a regular commit, closing the document would be a tagged commit of some sort. Your "hitting undo until returning to last saved state" would then be a single step, reverting to a timed, possibly named point.

For text based files, I think a versioning like system built into the filesystem would be ideal. Each save is just the diff. A nice UI to see/revert changes. Yet the lack of commit type messages would make those changes less friendly. I don't want to be burdened/slowed down with commit messages everytime I hit Cmd-S.

However, this would not work for binary type files like MOV, PSD, etc.

Ah, this reminds me of YesterCode, a tool that lets you scrub through code changes like a timeline.

Relevant HN thread: https://web.eecs.utk.edu/~azh/blog/yestercode.html

Storing diffs is not a great idea since then it requires that you apply them all to get the latest version. Notably, git does not store files as diffs [1] which is one of the reasons it’s so much faster than older diff-based VCSes.

[1] https://stackoverflow.com/a/43364484

I was forced to use Microsoft OneNote for a while and it was probably designed by someone with that mentality, and I absolutely HATE it. People manage to put unwanted changes into important pages all the time (the horrible Win10 default of not clearly indicating the focused window is certainly related, but that's another rant...) and the fact that it instantly syncs to the cloud for everyone else to see, made for some major embarrassment and irritation.

Changes should be saved with deliberation, not "whenever".

git commit, I suppose. Maybe something that doesn't have separate save, add, commit, and push steps.

Even in systems that continously save your progress there is a close analogue to manual save: Named revisions. Bookmarks of points in history that are better than the surrounding ones - points where some milestone has been reached, and some amount of proofreading done. Where there are no duplicated paragraphs or major rough edges like that.

But the floppy icon would not be a good fit for depicting named revisions

Sure, it’s copying your revision to a disk, writing the date on the label, and sticking it in a box.

The only difference between what is being described here and what we have been working with until today is how far undo/redo go.

For the most part the intent is to memorialize a snapshot of the work, a task the floppy icon has been fulfilling all along.

If the current document is Untitled, New File, No Name, etc and does not actually point to a file, then the ubiquitous Floppy icon should act as Save As. Once the file does exist, a simple Shift-click of the same floppy icon should also act as Save As. Same thing as Cmd-S/Cmd-Shfit-S. However, I'm unfamiliar with this modifier click save as from any app.

Reply on news.ycombinator.com