The data is stored in ~/.cache which has the contract that it user-wide cached data, which also means it can be deleted without severely impacting programs.

It seems the author has too high expectations of this feature, or vim is using an incorrect path to store this is they want to make it available more reliably

I switched from Vim to NeoVim this year, after about 15 years on Vim.

Not withstanding this incident, I would say that on the whole it has been a good experience with Neovim. (I didn’t actually ever use the persistent undo functionality in vim. Guess because of VCS it’s less needed for my use-case).

maybe they tried to undo the change, but were not able to

It was ostensibly necessary for other, arguably more important features. Persistent undo maybe just isn't that important? I certainly don't use it nearly as much as the author seems to.

It’s such an odd design decision.

I could see ignoring the old undo data or warning before discarding it but just silently wiping it is so user hostile it’s hard to comprehend.

Sorry for my ignorance, but what is the usefulness of undo persistence after a IDE restart? Don't you normally save your changes and finish a piece of work before exiting an DE?

Edit: some great examples in the replies here, thanks! Perhaps I should start using it in editors that support it, never gave it a thought before.

What did OP misunderstand? I am not sure how and where their understanding of "persistent undo" is different from "persistent across process restarts"?

I've used vi and nvi and (now) vim, and tried neovim, but :! is broken and “Conform to POSIX vi” is one of their “Non-goals”.

I've never used NeoVim because Vim has been good enough.

I used neovim because it felt way faster by default. I think treesitter runs circles around what classic vim is using to highlight syntax. That said, I never used both beyond basics, thus no horror stories either.

*vimdicated

If one really needs an undo in today's day and age, use git.

Keep in mind NeoVim forked in 2014, too.

Type A. Type B. Save. Type C. Save. How do you get back to state “A” using git?

You do not have all your states available.

Yeah, this hasn't been a problem since forever (or at least I haven't noticed). They had to break the undo file format a while ago to actually work correctly for byte-level buffer change events (very important for tree sitter and other plugins listening for buffer changes). The undo file format is versioned, too, so it's not just YOLO'd; Neovim has since forever returned an error saying there's a version incompatibility. The outrage here doesn't make a lot of sense to me.

The original author of this post (on Mastodon) appears to have a bone to pick with Neovim since it's "platforming white supremacists"? I couldn't figure out what this meant. Some sort of internet drama I guess.

Deleting important data without warning is not the same as not providing a feature users might want.

It is insane that people are defending behavior that is clearly abhorrent just because they like the software. Are the claims even true? If they are, you should be updating your opinions about the person writing this software.

All they had to do was pick a different file name

I've always assumed that undo history is ephemeral in any application I use, other than maybe an application where history is first-class in a timeline like Fusion360. I'm surprised to hear that people rely on it being persistent.

Not using it as a backup strategy. But it doesn’t matter. Vim has a feature, persistent undo. People are using it for whatever reason. Under your blessing or not. A different app, neovim, broke vim’s feature.

They don't get a pass because you disagree with an imagined use case.

https://xkcd.com/1172/

Seems so. As smart as keeping tabs open in browser instead of using bookmarks, but "workflow".

More like in the LLM era, people are disrespecting the user and not sweating these details with ever increasing velocity. It isn't good.

This story is about software being a slow, deliberate process where a lack of gatekeeping can lead to data loss. This is the type of problem which is getting worse.

The argument is that developers have a duty not to arbitrarily delete data on your system that you may have relied on that was produced by another program just because they’d like to replace it with something in their own format.

I don’t care if you’re volunteering your time; if you build something whose implied purpose and success depends on other people using it, you emphatically have a duty to those people not to silently destroy stuff that was there before your software was.

> giving away free software as a gift

Even a gift comes with an implicit promise that it will do no harm. Deleting important data of yours without warning is harm.

“Here, take this car, it’s free!”

“Ow, the gas pedal is actually a bear trap.”

“Why are you complaining? It’s free!”

A duty, like a responsibility, can be something you feel or choose for yourself. The fact that the maintainers of some software don’t feel it is a perfectly good argument for not using that software. There is no necessary connection to compensation or transactional thinking.

If I give away food I have a duty not to poison you. It doesn’t matter you didn’t pay for it.

They wrote this software with the explicit intention of offering it to other people to use. Their program deleted data created with a different program, on someone else’s computer. If they have no sense of duty that would preclude doing that, no one should use their software.

This is absolutely true. On the other hand, if there's Vim, Neovim, emacs, MS Word, Google Docs etc and some treat me with respect and others do not, that might affect my choice of which software to use.

Sure. And likewise, users who care about backwards compatibility have no duty to do anything for the Neovim developers--they can simply use a different editor that suits their preferences.

"Behold my glorious generosity, which eclipses your petty meaningless little data!"

This is the extreme version of "I enjoy coding but I hate users."

It may be legally valid in absolute technical terms, but I'm going to take a lot of persuading that it's a healthy attitude.

> They are open source developers, giving away free software as a gift. There is no duty here.

But actually there is! They didn't start from scratch. They took another very successfull and beloved project with the promise "to make it better". There is some promise here and the duty not to make it worse.

HN commenters constantly mistake “what I should do” with “what I am obligated to do.” Nobody is saying open source developers are legally mandated to be careful with user data. We are saying they should. There’s no need to haul out the license and put our lawyer hats on here. One can be within one’s legal rights and still be wrong.

Sure. And nobody has a duty to use it. This user states that (s)he doesn't want to use an editor that doesn't care for its users. I don't blame anyone here.

If people can be upset when llms delete a file, we can be upset when an open-source project deletes a file.

Ill remember this when I distribute malware.

Oh my. This set of principles is appropriate for malware.

> giving away free software as a gift. There is no duty here.

By that logic, if Facebook gives away their services for free then they don't have the duty to protect their user's privacy and mental health?

By your reasoning, a doctor who volunteers to provide free care to people has no duty of care to those patients. This is patently absurd - ethics and norms are a large part of what constitutes a professional.

And for what it's worth, I have flagged your comment for the inevitable pointless bickering it has precipitated. While applying reductionist frameworks and seeing where they lead is a necessary part of an individual's path to understanding, please avoid pushing ignorant assertions ("there is no duty here") as if they might constitute well reasoned truths.

There is not a duty but there is an image and quality issue. Something many open source projects suffer from and should not.

And even mentioning that results in "fork it if you're not happy" which immediately turns everyone off who's had to maintain a fork to fix a minor issue in something before. And anyone who can't fork it is being told to go to hell.

Everyone needs to quite frankly get off their high horse, crank the ego down and listen to users. Because you're damaging open source with the attitude.

30 years ago, things were better. They got a lot worse, particularly since github appeared.

You spewing bs like the left-pad dev who removed it from NPM a decade ago crashing everything.

Yes, OSS can start with just a passion without a duty, but as the scale grows you have a duty to make sure it does not have adverse effect.

If you don't like the duty, just make it die by building it crappy like VIM does.

Vim is always going to be obscure because it's not obvious from looking at it how you use it. Muscle memory is the entire point. You don't need to change any keybinds, and I don't. I did feel discouraged to learn it at first because the people introducing it to me were doing pointlessly fancy things in it, some combination of custom keybinds and scripts to mass edit files.

As for default plugins, it'd be neat if they curated a set of optional ones, but nothing should be preinstalled.

The simpler and less contentious way to adopt innovations is to make a new tool with the innovation. For example, you might like https://helix-editor.com/

> but even the way we talk about technology today. You need to use X, do Y or you're "not going to make it" / "escape the permanent underclass". It's bleak.

That's just how people market things these days, preying on desperation and fear of missing out. It's not how normal humans talk, I hope.

Software’s purpose is clearly shifting from “what’s good for the user” to “what’s good for the developer.” Instead of enabling me, software now seeks to lock me in. Instead of making my life easier, software decisions are made based on what makes developers’ jobs easier. Instead of being careful with my data, software now comes with giant legal terms that allow developers to be utterly careless with it. Software is now designed primarily to funnel money to the developer, not to bring joy to the user.

And look at this article’s HN discussion. Many people indignantly defending it. “It’s open source. If you don’t like it deleting your data, don’t use it!”

Talk about poor duty of care to users... been using him for 20 years and I have to enable it in my vimrc to take effect. So stupid. Why would I want this to be off?

Such amazing design...

" Enable persistent undo set undofile

Are you responding to the wrong post? This isn't anywhere in TFA

yea i found that a bit odd to throw in right at the end there. i dont really understand what that means

That wasn't the point.

The point was they did it in a completely stupid way and responded to a bug report about it in a way that suggested this might not be just the occasional stupid that we've all had slip into our code.

That is not the story here. The story is Neovim deleted data created by another program, on someone else's computer.

I don't know if this story is true, but you can't defend it when taken at face value.

I think this might not be clear on the issue, it broke vim's undo file, as in it deleted it and replaced it with Neovims version.

Just by trying Neovim you can lose your vim undo file.

…and even trying Neovim out on a file permanently deletes your undo history for that file, even if you switch back to vim.

As an open source developer I hate this attitude. If you do not care about the users why are you even releasing the software?