I was also a very early user of Neovim.

The way I personally remember it being positioned was “Vim, but with breaking changes.”

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.

The “drama” was linked in TFA:

https://github.com/neovim/neovim.github.io/issues/501

Gotta be honest, this seems like making a mountain out of a molehill. Yeah, DHH is an awful person. His endorsement was removed from the page pretty quickly, but of course not fast enough to avoid the social media mob handing down their verdict upon the thankless maintainers. I sympathize with the Neovim developer in that thread, the driveby Github commenters with seemingly no other involvement in the project are some of the least well-socialized people alive.

To be fair, it’s not hard to say “white supremacy is bad and I’m not cool with it”

It took me only 10 seconds to write.

tl;dr: the website showed the quote “Full-screen Neovim looks cool as hell!” by some programmer with political views. After initial pushback it eventually got removed

programmer with political views

It's dishonest to downplay what his "political views" entail. He compared the removal of minorities to pest extermination.

When wolves get out of control, you shoot them. When gypsies take over public spaces, you deport them.

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

We can speak, respectfully, of how important backwards compatibility is to us, and ask nicely for them to give more of their time to support it when their free sodftware isn't backwards compatible. Perhaps we can even offer to help implement it.

But they have no duty to do so or to "care" for their users. (They have already demonstrated they care for their users, btw, by giving them free software.)

EDIT: I missed an important part of the story, which is that they mutated existing files in a non-backwards compatible manner. That should have been avoided, I understand where the (secondary) author is coming from now.

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

Software isn’t food.

So software that deletes important data of yours without any warning is ok because at least it isn't poisoning you?

If you have to twist things so far that intent doesn’t matter, something’s wrong.

According to TFA, it was completely intentional that they deleted someone’s data that had been created with a different program. Otherwise they would have acknowledged it was a bug. I do not know if this is true, only that it is what TFA claims.

You must feel clever completely missing the point on purpose like that.

This guy you are arguing with is classic troll, he does it on every topic. Just ignore and don't reply.

"Your analogy is false because the two things you are comparing are not literally the same, dear sir!" is such a classic Internet discussion trope that it must have a name. If it doesn't, can I please name it? Maybe Perfect Analogy Fallacy?

But they couldn’t be further from different. You have to have a health inspector visit your kitchen just to sell food at all. You need affirmative permission from the government to sell food.

Yes, everyone is aware of that. The parent poster was bringing up the example of food to demonstrate that our society does not agree that giving something away for free doesn't mean you have no obligation as to potential adverse effects of the thing.

Analogies like this don’t work when comparing against heavily regulated industry.

Neovim being free software is a lot different than United Airlines giving me a free flight or my doctor giving me a free consultation.

It’s very true that you can go to civil court and make a claim that a business or individual harmed you. If you do that with Neovim the judge is going to pretty quickly read bullet point #7 of the Apache 2.0 license, you’re going to struggle to prove any kind of mal-intent, you’re going to tell the judge that you paid $0 for the software, and you’ll be pretty quickly sent along your way with no damages awarded.

Only in the sense there's no explicit legal responsibility.

Do you really believe developers have exactly zero moral responsibility to their users? None at all?

Really?

Would you still believe that if you found the developers of ssh deliberately included a backdoor for hackers, or neovim was uploading everyone's code to the NSA?

It's not poison, it's a broken feature. And you have the source code. Fix it if you like.

Others are eating it and are fine, chances are you’re allergic. Fortunately all ingredients are listed, you can check - or even modify the recipe yourself.

Fortunately all ingredients are listed

How does this translate to the vim situation?

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

If you don’t like how it works, go build your own.

I already build software where I hold myself to a higher standard than malware, so not sure I get your point. Why not strive for a better world with good software?

Your suggestion that it is malware is misleading. Malware is “any software intentionally designed to harm, disrupt, or steal data from computers”. I sincerely doubt that was the author’s intention.

Everyone in open source is trying to write good software and the definition of good is subjective depending on overall design, features, ease of use, quality, and performance.

If an open source project is missing a feature, go build it. If the project maintainers don’t want it, fork the project. Be the change you want to see in the world. That’s the beauty of open source.

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.

This gift comes with the following clauses listed plainly in the license file:

   7. Disclaimer of Warranty. Unless required by applicable law or
      agreed to in writing, Licensor provides the Work (and each
      Contributor provides its Contributions) on an "AS IS" BASIS,
      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
      implied, including, without limitation, any warranties or conditions
      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
      PARTICULAR PURPOSE. You are solely responsible for determining the
      appropriateness of using or redistributing the Work and assume any
      risks associated with Your exercise of permissions under this License.

   8. Limitation of Liability. In no event and under no legal theory,
      whether in tort (including negligence), contract, or otherwise,
      unless required by applicable law (such as deliberate and grossly
      negligent acts) or agreed to in writing, shall any Contributor be
      liable to You for damages, including any direct, indirect, special,
      incidental, or consequential damages of any character arising as a
      result of this License or out of the use or inability to use the
      Work (including but not limited to damages for loss of goodwill,
      work stoppage, computer failure or malfunction, or any and all
      other commercial damages or losses), even if such Contributor
      has been advised of the possibility of such damages.

I don't think anyone is looking for legal remedies, this is not the right layer.

Is some part of:

"Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE."

Unclear? The fact that it's part of a license does not make it a legal-system-only warning.

The software might eat your dog, and feed your homework. Run it at your own risk, and be prepared to submit patches or fork it to make it behave the way one prefers.

The software might eat your dog, and feed your homework

Sure, and when it does we can say “this piece of shit ate my dog, and the authors of the software have no concept of a duty of care to their users”. And no amount of “well, axually…” is going to make any difference. I have a hard believing someone is copy-pasting a license file in good faith in response.

Most open source software is written by individuals who aren't paid for the effort, and are solving their own problems. Presuming that they feel an obligation to the folks who download and use their work for free seems... bold.

If my neighbor mows my lawn for free, I'm not going to complain about his workmanship. If I want the job done a particular way, the solution is to do it myself, or pay someone to do it the way I like.

This is one of the most exhausting (and frankly, exhausted) recurring arguments that comes up over and over again on HN.

Some bit of open source software does something bad or unwanted which causes people point out that it shouldn't do that bad thing. In this case, not even "the authors of this software should be held liable for the software doing the bad thing", just, "Hey, the right thing to do would be to update the software to not do the bad thing."

Why does this always lead a zillion people to come out of the woodwork to point at licenses and warnings or whatever? Like, yes, there's a warning. Your software having a warning doesn't mean people can't criticize you and your software for doing bad thing. Your software license does not give you immunity from criticism or from people saying you should change your software.

No, you don't have to change the software. Yes, other people are within their rights to fork the software themselves. But they can also point out that they told you that your software was doing the bad thing and you didn't fix it or change it, and that as a result they don't like you or your software or both — whatever. Nothing at all wrong with that.

It's genuinely mind-blowing to me that software can do something obviously bad, someone can point it out, and then someone will link to the license file to say they have the right to do it.

That's such an obvious category mistake that I'm not sure how to respond. It almost feels like a bad-faith interpretation of Wichary's original point.

Equally mindblowing that folks feel someone hacking on open source software has an obligation to do anything the way they feel it needs to be done when the whole point is that anyone gets to do more or less what they want with the code.

You can't have both.

There's a long literary tradition of representing contracts as a tool of villainy. Signing them is generally treated as a Faustian bargain.

This is a great example of why. Most humans have a sense, deep down, that contracts often exist to bridge the gulf between the ethically defensible and the legally defensible.

It's hard to imagine that any sane person who is just looking to use a popular editor would read some broad limitation of liability language like the above, and interpret it to mean, "By the way, we intend to quietly delete certain files created by a competing fork of this project whenever we find them."

It's true that contracts with liability limitation clauses like this are an absolute necessity in this day and age. But there's also a non-legal principle of mutual respect that is absolutely necessary to a healthy open source community.

It's hard to imagine that any sane person who is just looking to use a popular editor would read some broad limitation of liability language like the above, and interpret it to mean, "By the way, we intend to quietly delete certain files created by a competing fork of this project whenever we find them."

Forks of projects trodding all over each others files is one of the more common problems that has happened, historically. Prior to the major efforts around freedesktop.org around configuration standardization, it was quite common. It'd be one of the first things I looked for when switching to a fork.

I’m not saying it doesn’t happen. I’m saying it shouldn’t be defended as good. It’s a defect. And in this particular incarnation it’s a defect that directly clashes with fundamental Free Software principles such as personal digital sovereignty.

I also suspect that few people actually believe it’s ok and these legalistic defenses are more about circling the wagons. How many people would defend Microsoft if a new Office version automatically and quietly stripped edit history from documents that were originally created by other versions? Would we be hunting for limited liability clauses in their EULA to defend the design decision?

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.

"Better" is subjective. They made it better...for themselves. Then gave it away so people who share their opinion, had the opportunity to choose to use it.

Then gave it away so people who share their opinion, had the opportunity to choose to use it.

How many neovim users were made aware that the software would proactively delete their decade-long file history?

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.

Is there a good way to avoid programs like this in general?

You buy software that includes a commercial license that guarantees data retention

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.

It's worth pointing out that vim is not "another program" as far as Neovim is concerned. It's an earlier version of the same program. Neovim is a fork of vim, not a totally different editor that happens to share part of a name.

Forking creates new programs.

If I fork chromium, I do not get to claim that I am a chromium maintainer.

Vim and Neovim are two seperate programs.

It absolutely is another program, I can tell this because it has a different name. To run it I type "nvim" instead of "vim". I use different config files to control its behavior. I install a different package on my system when I want to use it on a new computer.

If it really is another program with reference to vim, it should leave undo files made by vim alone.

If it's going to nuke vim's undo files, it can't hide behind "another program".

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

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

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

Then you don't take the car. Why is this confusing?

Ill remember this when I distribute malware.

TLDR: Neovim did a breaking change to persistent undo

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.

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.

As a Neovim user, this stopped me dead with painful realization: I may have suffered the same thing but didn't realize it. There was a time when I could not undo something, and it was after a Neovim upgrade.

Unlike Dr. Chisnall, I started my editor journey on Neovim, so it wasn't a transition that bit me. However, if the format of the persistent undo file is unstable, and Neovim just deletes it when it doesn't recognize the previous format, then it seems conceivable (to me) that an upgrade after changing the format would delete the file too.

Ouch. This is making me think about getting off of Neovim. Yes, FOSS comes as-is, but if there's an alternative...

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.

If you ignore it, do you continue allowing edits to the file? Now undo history is corrupt and useless anyway. Or do you disallow editing until the user manually deletes some hidden, implementation-detail file for a feature they probably never use?

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.

How does one use persistent undo in vim?

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

It’s somewhat important for privacy reasons that the feature is opt-in. I don’t know if that’s the reason historically, but I wouldn’t want a text editor to persistently store a copy of everything I type without my consent. It’s almost like a keylogger.

Making privacy-sensitive features opt-in is a form of duty of care as well, to avert harm from the user.

the attitude that just because something is a persistent file on your filesystem that contains data that you might want is no reason for their program not to delete it meant they had no concept of a duty of care to their users.

That's the wrong way to look at it. NeoVIM has a different concept of care for their users. They're optimizing for another kind of care, more in line with modern expectations, which VIM did not care about (hence the fork).

It's not better or worse, just different.

This same article could've been written about how VIM has no native LSP integration or autocomplete and they don't have duty or care for their users.

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

There is a flip side to this - is vim encrypting this data it keeps forever? If I delete something I consider sensitive, I might unwittingly be recording that presumed-deleted piece of data to my user profile somewhere to be deleted never.

Stop looking for post-hoc justifications for behavior that is clearly wrong.

Second time in this thread you’re telling other people how to think and behave because they aren’t acting like you

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.

Insane? Abhorrent?

Relax for a second. Get some perspective.

From Cambridge Dictionary:

```markdown

abhorrent

/əbˈhɒr(ə)nt/

Abhorrent is an adjective that means morally very bad, hateful, or causing strong disgust and loathing.

```

I realise that this causes strong disgust and loathing in you, but can you please expand upon how it's morally very bad to prioritise speed and ease of use over undelete capability in Neovim? Are you unable to make backups or use Git?

All they had to do was pick a different file name

True. But it’s not like they planned some vengeance against the VIM backup file.

People are making it sound like this is a huge company with a product and not a grouping of curious people with a couple hours of free time on a Sunday.

Most likely they never thought about it, then it broke, then it was not impactful enough to fix on their free time compared to other stuff.

"Vibe shift" is all the rage these days but one area where it's most apparent is modern software.

People of Raskin's vintage had a very humanist approach to computing. The mentality was very much an outgrowth of the cultural revolution of the 60s. Computer usage should be joyful rather than toiling. The computer should help you. It should make you feel good about what you create.

That stands in stark contrast today, where things are more hostile. Not just in terms of "Dark patterns", or writing off user needs for the sake of expediency... 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.

I recently restored a vintage Macintosh SE I picked up at VCF Midwest and despite its limitations that machine was an absolute JOY to use despite its limitations and nearly 40 years of age. This was a machine and software designed by Raskin's contemporaries and it shows.

I've used vim since the first time it appeared in Debian repos. I have been told a thousand times that NeoVim is better, more modern and solves many (conveniently never cited) issues. I just ignored it and carried on. Feeling terribly vindicated at this point as it's a feature I use regularly and have no idea that it would be an issue in NeoVim.

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.

I haven't noticed any performance issues in vim to start with. It was fast on a 75MHz pentium for me. The syntax highlighting, same. No issues. I don't always use that though because I can't be bothered to set up anything much past the basic config.

At one point vim lacked asynchronous plugins. If a plugin was running a builder or linter it locked the editor up (from what I recall).

That fell apart when people wanted vim to do some more modern IDE kind of things like all the “… on save” stuff (build on save, test, lint, etc). I think LSP support is native in neovim as well.

I believe vim merged asynchronous plugin support a while back though, so I’m not sure how different they really are anymore.

That seems like solving the wrong problem.

Just run make from another terminal...

It was a real problem, but as GP already mentioned, Vim has integrated some version of it since Vim 8 (2016), probably at least somewhat motivated by NeoVim (forked 2014).

https://lwn.net/Articles/713114/

IIRC vim became really slow with the combination of large source files (thousands of lines of code) and language server plugins (e.g. code completion and live error squiggles).

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

To be the devil’s advocate here, I think Vim needs less backwards compatibility, not more. In the sanctifying of “muscle memory” it completely stopped innovation, to the point of slowly drifting to obscurity.

Of the over a hundred students I taught when I helped out in uni, basically no one wanted to learn it, despite my enthusiasm.

And I sympathise. As I get older, I slowly grow more and more distaste for software that does not respect my time enough to give me properly-crafted defaults. Vim, in the age of modern editors, cannot compete. Not without 20 plugins with conflicting shortcuts and its self-imposed cliff of a learning curve.

And I’m saying this from a place of love; I’ve been using Vim (at least as a VSCode extension) every day for the last 10 years. But it never really grew up to the promise that the “Vim Creep” essay [1] gave me.

[1]: https://web.archive.org/web/20190227031109/https://www.norfo...

:wq

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/

It’s Open source.

Some people just want to keep looking at the gift horse in the mouth.

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

It’s a free country.

Apparently now they’re platforming white supremacists. I am completely unsurprised. Different facets of the same underlying attitude.

This was the end of the original Mastodon. Which is why I just can't with Mastodon or Bluesky. Casually tossing around ridiculous claims to back up an opinion on persistent undo.

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

Am I missing something? Are people using persistent undo as backup?

This seems however more like of a documentation and UX problem. Neovim should warn and ask before deleting old undo files, or at least back them up, but it's not neovim's fault if people don't use reliable backup and versioning systems. Relying on persistent undo for this is kind of a self inflicted wound.

Use the proper tools for the job. Saying that neovim developers "had no concept of a duty of care to their users" is really disrespectful. Neovim's Lua API is overflowing with care, you just need to go look.

https://xkcd.com/1172/

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

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.

Yeah, they could have done better, but to say they "had no concept of a duty of care to their users"... Isn't it a bit much?

The entire story is a setup for a remark about a Neovim maintainer's refusal to remove a David Heinemeier Hansson quote from the Neovim homepage [0]. So with that in mind the rhetoric makes sense.

[0]: In spite of the author at Unsung saying that Neovim is "in news" for other reasons. Chisnall's account is being given in the immediate context of that news.

This story has no references that support the author's version of events, but it does appear to be substantially true that:

1. The change would break undo history, for both Neovim and Vim.

2. This means Neovim would delete data created by a different program, on another user's computer.

3. This was known before the feature was released.

4. They did it anyway.

I don't think there can really be any post-hoc justification of this.

https://github.com/neovim/neovim/pull/13973#issuecomment-789...

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.

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).

According to the rev history for VIM, persistent undo arrived in version 7.3, released in 2010. So Chisnall may have used it since 2000, but he didn't have persistent undo for at least two of the books he wrote. And it means it wasn't "maintained for almost 20 years", it's at best 16.

But it is a nice feature.

I do that by using version control. I have it hooked to my editor so that "save" is "check in". Now I have persistent, versioned, copies of all my states independent of whatever tools I happen to be using.

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.

Today it's the work of a moment to get a coding agent to change the format of a file for you. I guess the point of this story is supposed to be like the famous Van Halen brown M&Ms contract clause. But the world is changing fast and I think it makes sense to start taking more ownership of your own computing experience, especially when the software you use is open source. If you don't like it, have an agent change it! You don't need to convince a maintainer of anything.

While I agree with the article's point, we should note that collisions do not happen out of the box because Neovim defaults undodir to $XDG_STATE_HOME/nvim/undo/ (~/.local/state/nvim/undo/), while Vim defaults to storing .un~ files alongside the edited file or inside ~/.vim/undo/. Data loss only occurs if both editors are configured to share an undo directory or save inline .un~ files.

Undo files and persistent undo are not meant to work that way. They are just persistent across process restarts. That's all.

They live in ~/.cache which is defined as "user-specific non-essential (cached) data".

Despite this user's impressive résumé, they simply misunderstood the feature.

In what way is it not a process restart if I stop the process, install/upgrade NeoVim and start a new process?