Unrelated to this whole drama, you may want to look into them! Lack of registers, and especially position registers, is pretty much the thing I miss the most in VS Code. I don’t use text registers that much – I mean, I use them a lot for macros, but not that much outside them; but life without position registers is extremely bewildering for me :-D. Debugging a stack trace without position registers makes me feel like Fred Flintsone when he’s driving.

I think the missing piece of context is this: Emacs registers are a very, very old Emacs feature. It’s so old that people have their own mental models for using it. Not just muscle memory but a long series of idioms for dealing with them. This is a change that breaks many, if not most of them, in order to fix a slight inconvenience that a lot of people either don’t have, or have found other ways to deal with in a way that doesn’t introduce the additional interruption. The author of the patch may have misunderstood just how big its impact was because some of the things commonly done with registers can also be done with helm. I don’t think they’re “rogue”, as the blog post calls them; Thierry Volpiatto is also the author of helm, I think quick register access just isn’t that big a deal for him.

A fork definitely sounds a little, uh, excessive though :-). Emacs is an old program, and supporting the usage patterns of the multiple generations of users it has is definitely a big deal.

Just to illustrate how big the difference in usage patterns is: @timthelion mentioned here that they just learned some people use registers as the primary mechanism of switching buffers, rather than using helm. I don’t even use helm, not for switching buffers, not for anything else, actually. It was forked from anything.el way after my conversion to the Church of Emacs :-) and never found I needed it. I have a rough idea of what it does, I tried it like forever ago (actually I tried anything.el, of which helm is a fork), found it super confusing and never looked at it again for years. I occasionally run into it when setting up development environments for newer tools/languages (e.g. Rust), I still have no idea what to do with it. Maybe some major mode I’m using it is using it for prompting and I don’t realise it yet – it’s definitely not installed on the machine I’m writing it from but I’m running an older .emacs here – but I’ve never deliberately used it myself. I don’t think it’s a bad tool, it’s just not how I like to use things.

I can see why this would be seen as a “hostile” change, especially as there’s no easy way to restore the old behaviour (which honestly is all I’d want, too; I’m all for making it easier to support helm environments, which are super popular, and “good defaults” is a meaningless notion in a 40 year-old program IMHO, and especially one as extensible as Emacs). But a fork that preserves the environment for Emacs dinosaurs (myself included) is unlikely to fare well; historically, backwards-looking forks tend to settle into backwards-oriented tools that only bitter angry people use.

I think the over reaction came from telling power users they need to slow down and press RET because they don’t know what they are doing, almost like touch typing doesn’t exist. :-)

Debugging a stack trace without position registers makes me feel like Fred Flintsone when he’s driving.

Navigating without registers doesn’t mean navigating manually. =) The xref tooling maintains a position ring for you, so I mostly don’t feel the need to mark positions myself, other than occasionally with the mark ring.

OTOH, running a bleeding edge version and reacting to a feature change can still have some effect, if using the HEAD version.

When using a stable branch, when the feature will finally come to the stable version, it’s probably too late for any changes to be made, because the feature has been living in the master branch for a long time. Using a stable branch mostly means that we assume we won’t get any breaking changes to the software, but when the changes come, we’re OK with it.

But no more, not in GNU Emacs 30. It’s gone, without as much as a NEWS entry to inform the unwary user about this regression.

Additionally, for a contributor to the Emacs codebase, running off of master makes things easier.

You can store a bunch of things in registers – texts in selections (both linear and rectangular), window layouts, positions in files, files and buffer names, macros. The ones I use the most frequently are file positions, macros, and selection text, roughly in this order.

The first act kind of like ad-hoc, non-persistent bookmarks and are pretty much how I navigate immediate call hierarchies, call stacks etc.. The second basically expand the macro space; for anyone who’s more familiar with multiple cursors than macros, register macros are akin to being able to save and recall a number of multiple cursor sequences, so if you need to do a particular multiple cursor operations again, you can just place the cursors again and redo it with a key press. Selection registers are basically just clipboards with ad-hoc names and random access, that’s nothing fancy.

I think these and buffer/file names (I don’t use that but I know people who do) are the most common operations that this change breaks. It’s a pretty big change because doing any of these with registers “feels” like interactive commands and has felt like that basically forever.

E.g. a common pattern for me is to have every level of a stack trace in a register when I’m debugging a core dump, so I can navigate the code more conveniently in a view separate from that of the debugger session. I still do most of the debugging from a debugger view, but sometimes I want to have a better idea about what’s happening “farther away” from the call stack state – e.g. because I suspect the bug is actually somewhere else entirely, or I have an idea for a fix but I want to see how I might integrate it. So I peek at the code here and there, then jump to a call stack level to see how a change might affect state relevant to that stack trace, then go back to what I was reading the last time (that’s always register s for me, everyone has their register convention though) and so on. All that while keeping the debug view intact.

I’m not very familiar with vim, I’m pretty sure it has equivalents to all these – I’m only mentioning all this for context.

My absolute favorite xkcd comic.