Irreal

This should probably be a Red Meat Friday post but I really hate camel case. It’s hard to read, hard to type, and looks ugly. Among it’s many other sins, it has made abominations such as subword mode necessary.

Over at Emacs Elements there is a (very) short video on using subword mode. There’s not much to say. It’s a way of having forward-word skip to each capitalized segment of a camel case word. The video recommends enabling it via a hook function for whatever programming modes you use. You can, of course, toggle it manually by invoking Meta+x subword-mode.

Some people love this mode but—the awfulness of camel case notation aside—I’ve never seen the point of it. Yes, occasionally it’s convenient to have forward-word stop at each subword of a camel case identifier, but most often you want to treat the camel case word for what it is: a single symbol. In those rare cases (heh) where you want to put the cursor on one of the subwords, it’s easy enough to skip to the head of the composite symbol and move the point to the correct spot. Or you could use something easier like jump-char-forward. Regardless, it’s hard to see the utility of subword-mode.

Still, people differ in their needs and if this is something that’s useful for your workflow, Emacs, as usual, has you covered. The video is only two minutes, 25 seconds so you should be able to slip it in easily.

UPDATE [2023-09-01 Fri 12:39]: Mickey writes to tell me that I may have been too harsh on subword mode. What really happens when you invoke it is that the definition of a “word” is changed to encompass the subwords of SomethingLikeThis. That means that not just forward-word but any word-based command can stop and act on the subwords.

That makes it more useful than my original post suggested but I still think that usually you want to treat “SomethingLikeThis” as the single symbol that it is and subword mode is almost always overkill. As a real world, real time example, I misspelled SomethingLikeThis as SomethingLikrThis but rather than toggling on subword-mode and moving back to the error, I simply called jump-char-backward and went right to the error.

I ran across this Toot—or whatever Mastodon calls it—in Sacha’s weekly Emacs News:

Even though it’s sort of old news at this point, it’s worth calling attention to. The idea is to use occur to narrow down the files in a Dired listing and then invoke the occur edit function to change the names of those files.

You can do the same thing from within Dired only but I like how the two-step process narrows down the files you’re concerned with and avoids errors. It’s a nice tip and worth taking a look at.

Mike Zamansky has published the latest video in his Learning Elisp series, Learning Elisp 8. It’s the second video about building a function to generate function header comments. This video continues the discussion of regular expressions by considering the rx macro and the related xr package.

The rx macro allows you to write a regular expression with a more functional notation. The xr package is the inverse of rx: it translates a regular expression in normal notation to the corresponding rx notation.

Some feel the rx notation is easier to use and understand than the traditional regular expression notation. In fact, Pay08 in the reddit discussion of Learning Elisp 7 complained that Zamansky didn’t mention rx, which he considers a must for dealing with regular expressions. I’ve never been able to warm up to using the rx macro and agree with Zamansky that it’s probably not worth learning because it applies only when writing Elisp and not to any of the other languages or utilities that have regular expressions. Zamansky suggests that the xr package may be useful for understanding regular expressions written in traditional notation but I don’t find the rx notation any easier to digest; your mileage may vary.

Finally, Zamansky considers the format function, which, as he says, is pretty much the same of C’s printf. With this video, Zamansky has discussed everything he needs to begin building his function header function.

The video is just short of 20 minutes so plan accordingly. It’s a nice introduction to the rx macro and related xr package so you should take a look at it if you aren’t already familiar with them. Don’t let my and Zamansky’s skepticism sway you; you may like them.

James Dyer has a quick tip that may be interest you. The issue is reverting buffers. There are several ways of doing this. One is to simply call find-alternate-file (Ctrl+x Ctrl+v). That’s what I always did but there’s the more specific revert-buffer (Super+u) that handles a few edge cases.

The problem with revert-buffer is that it asks for confirmation. If you’re calling it interactively you probably don’t want the confirmation. Dyer’s tip is to use revert-buffer-quick instead. It’s like revert-buffer but (usually) doesn’t ask for confirmation. Take a look at the online documentation to get the details.

Here’s another tip, this time from Irreal. If, like me, you usually call revert buffer for particular files or for a particular directory, you can set revert-without-query to inhibit the confirmation query for those files or directories.

In a sense, this is all small potatoes. Whether you need to confirm your intentions or not doesn’t matter much in the end but the thing about Emacs is that it does all it can to reduce friction in your workflow. It’s also a case study in why your mastery of Emacs is never complete. Both revert-buffer-quick and revert-wthout-query are obscure features that are hard to discover on your own but they’re there to help you even if they’re hard to find.

Isa Mert Gurbuz has an interesting post on some of the editing workflow he’s developed over the years for working with Emacs. The bulk of the post demonstrates some of the glue code he’s developed for working with various packages.

He starts with executing code in a buffer. You might want to execute the last s-expression, a defun that the cursor is in, a region, or even an entire buffer. You can do all that but each of them has a separate command. Gurbuz’s solution is to write a DWIM function that does the right thing depending on context. Nothing too unusual about that but he’s applied a bit of abstraction. The context remains the same for many languages other than Elisp but the particular functions vary. His idea is that his DWIM function doesn’t call any of these functions but returns a function that does. That way, he can supply the appropriate functions to call to his DWIM metafunction and get the actual function to call in return. He binds that directly to a key shortcuts so there’s no reason to even name the resulting function.

Next he considers eros as a way of showing an enhanced view of an expression, again in a DWIM way depending on context. He uses the same trick and metafunction as above to get a function appropriate to the language he’s using.

After that, he considers some functions from other languages like redshank from Common Lisp and clojure-thread-* from clojure-mode. Finally he considers various other supplementary functions and how he integrates them into his workflow to handle things like indentation and formatting. It’s a nice post with some good ideas. Definitely worth a few minutes to read.

Most every Magit user is, I’m sure, aware that the Magit menuing system has been refactored into a separate library, transient, that is available for anyone to use. I’m dimly aware that some Elisp projects—although I couldn’t name one off the top of my head—are already taking advantage of it. I just stumbled across a case of transient being leveraged in an individual user’s configuration.

Tory Anderson is using transient as a replacement for hydras. Emacs hydras are a package by abo-abo that provides a straightforward way to configure menuing systems in Elisp. They’re easy to set up with a simple description in your Elisp. You can take a look at Anderson’s post to see the code for one of his hydra replacements. I have a hydra that does essentially the same thing and the code looks almost identical.

To me, the interesting thing about Anderson’s post is not a particular hydra replacement nor the particular problem he’s solving but the idea of using transient instead of a hydra. I don’t see any advantage to using transient instead of a hydra and even Anderson says his efforts to replace hydras with transient are mainly a proof of concept. Still, it’s an interesting idea and shows how easy it is to take advantage of the transient library. Anderson has another post on transient and hydras if you’re interested in the idea. That post notes that the transient documentation is available in the Emacs help system as long as Magit is installed.