Irreal

If you’ve been following the Emacs native compilation effort and are curious about the technical details, Andrea Corallo, Luca Nassi, and Nicola Mancahave have an arXiv paper that describes Bringing GNU Emacs to Native Code. The paper does a good job explaining the technical details of how the native compiler works without requiring specialized compiler theory knowledge.

The TL;DR is that the native compiler uses the intermediate language from normal Emacs byte compilation as input and produces GCC intermediate code (IR). The final step is for GCC to compile this IR into native machine code. It’s a nice solution because it lets GCC worry about generating the final code so the solution should work for any architecture that GCC targets.

The details are a little more complicated, of course. The Emacs byte code IR is first translated into a special IR (called LIMPLE) that the native compiler can operate on and make optimizations that GCC can’t for various reasons having to do with the differences between LISP and C. It’s LIMPLE that is actually translated into the GCC IR. The paper explains all this so you should definitely read it if you’re interested.

Emacs-Elements has a short video that describes three useful packages that save various pieces of Emacs state. The three packages are:

1. real-auto-save
2. persistent-scratch
3. session

The first, real-auto-save, saves the file you’re working on when Emacs is idle for a configurable number of seconds. Most people probably wouldn’t want this globally applied so you can set hooks to only do it for the type of files you want to automatically save.

The persistent-scratch package does just what it says. It will save your scratch file across Emacs sessions. That’s handy for folks who actually use it to take notes and don’t want to lose those notes when they restart Emacs.

Finally, session saves things like the values you’ve stored in registers. Follow the link to see a list of all the things that session saves. I’ve never been a fan of this sort of thing but many people are so if you’re one of them, take a look at the package.

The video is only 6 minutes, 17 seconds long so you can probably watch it while you’re waiting for your coffee to cool. These packages are good examples of small Emacs apps that help you adapt Emacs to work the way you want it to.

David Wilson has a new video out on efficient text selection in Emacs. You can’t really understand text selection in Emacs without understanding the mark. The basic fact is that the currently selected text—the region in Emacs lingo—is the collection of characters between the mark and the point.

Wilson explains how to select text regions by setting the mark and then moving the point. When you have a region defined, you can perform any of several operations on it. That can be anything from simple cuts and copies to more esoteric things like changing the case of every character in the region. Mostly, you learn those commands as you go along but the first thing to learn is efficient ways setting the region.

Emacs, as you’d expect, has many shortcuts to set the mark and then move the point to some predetermined place. For example, there are commands to mark the current word, paragraph, page, or buffer. There are even move specialized commands for Lisp code that deal with things like marking the current s-expression or function definition.

Of course, that’s only half the story about marks. You can also jump to them. Even more, they’re saved in a special structure called the mark ring. Thus, one can jump to the last \(n\) marks where \(n\) is the size of the mark ring. The mark ring has 16 entries by default but, being Emacs, it is, of course, configurable.

Wilson explains all this and more in the video so be sure to take a look. His demonstration of the global mark ring falters a bit at the end but it’s still a very worthwhile video. The video itself is about 28 and a half minutes so plan accordingly.