Irreal: Always-yes

Gene Goykhman, like a lot of Emacs users—or simply computer users, for that matter—hates dealing with fussy details while working on his computer. One of his complaints in particular is that there are too many confirmations in some of his frequent tasks.

For example, when quitting and saving an Ediff merge, he has to respond to two separate confirmations. His solution was to write a wrapper function that replaces the confirmation queries with #’always. It’s pretty simple code and easily understandable. He binds it to a keystroke to unconditionally quit whatever function he wants to quit without the bother of confirmations.

This is yet another example of the difference between Emacs extensions and the plugins used by other editors that I wrote about previously. You almost certainly couldn’t make this change with an editor that relies on plugins.

In any event, if you’d like to get rid of some of the superfluous confirmations in your Emacs workflow, give Goykhman’s post a read.

-1:-- Always-yes (Post jcs)--L0--C0--June 12, 2024 03:42 PM

Charles Choi: An accidental lock-in feature of the Apple ecosystem

It’s WWDC week, when Apple shines their spotlight on its developer ecosystem every June. Given the moment, I’d like take this opportunity to give all the flowers to the unsung developers who have built and maintained a feature in Apple products that I hold quite dear: the Emacs keybindings in Apple UI frameworks.

If you don’t know, when using a macOS native app like Notes, OmniGraffle, or Safari, you can use the following keybindings in any text field:

  • C-a - move cursor to beginning of line
  • C-e - move cursor to end of line
  • C-f - move cursor forward one character
  • C-b - move cursor backward one character
  • C-k - kill text to end of line
  • C-y - yank killed text (mostly, more on this later)

It can not be overstated how extraordinarily convenient this feature is to Emacs users. Even more astonishing is how this set of bindings has continued to be maintained (since 2001!) across the different OS variants Apple ships (macOS, iOS, iPadOS, tvOS).


My anecdotal understanding of this feature’s history is that it started with the NextStep OS back in 1997. The developers of NextStep used Emacs and so whenever they typed in the text widgets of the NextStep UI, they naturally wanted to use Emacs bindings. It was unlikely that this was ever an exec-level requirement. But the developers wanted it, so they made it happen.

Fast forward in time, NeXT effectively acquires Apple and in doing so repackages the NextStep frameworks to ship Mac OS X (now called macOS). This decision fatefully keeps NextStep’s text system and its conventions intact in the UI framework called AppKit as part of family of frameworks called Cocoa. Fast-forward to 2007, the iPhone becomes a thing. Apple makes another fateful decision to build iPhone OS (now called iOS) off of Cocoa but create a new touch-based UI framework called UIKit. UIKit’s text system is heavily influenced by Cocoa where it too carries over the Emacs keybindings. Variants of iOS in the form of iPadOS and tvOS come to be, further propagating these keybindings. In 2019, a declarative UI framework called SwiftUI is created where its text system too adopts the Emacs keybindings.

Configuring Keybindings in macOS

Wonderfully enough, you can still configure the keybindings in AppKit-based apps on macOS using the NextStep style configuration as shown in the Text System Defaults and Key Bindings document. There it provides guidance on adding more Emacs-style keybindings.

Of note is that macOS has always supported an alternate clipboard to emulate the Emacs kill-ring. This works independent of the system clipboard, and requires a bit of configuration to get working. There are two steps to this:

  • Redefine the keybinding C-y to yankAndSelect:

In the file $HOME/Library/KeyBindings/DefaultKeyBinding.dict (for details see the link above), add the following line in the body between the braces.

"^y" = "yankAndSelect:";
  • Use the command line utility defaults to set the variable NSTextKillRingSize.

This variable controls the size of the kill ring. Here we will set it to 5.

$ defaults write NSGlobalDomain NSTextKillRingSize 5

You can confirm the value in NSTextKillRingSize as follows.

$ defaults read -g NSTextKillRingSize

Refer to man defaults for more information on it.

At this point, you will need to log out and back in for the new keybindings to take effect.


You can’t have everything though as not all apps are built with AppKit. Focusing on only the default Emacs bindings, here’s a survey of the different levels of support for them from the different UI frameworks.

Binding AppKit/SwiftUI (macOS) UIKit/SwiftUI (iOS, iPadOS) Mac Catalyst
C-a Y Y Y
C-e Y Y Y
C-f Y Y Y
C-b Y Y Y
C-k Y Y Y
C-y Y N N

Unsurprisingly, UIKit chose to not support a kill ring, so effectively C-k is a delete function and yanking is not supported. The column for Mac Catalyst is a category of apps built to work for both iPadOS and macOS based largely on UIKit. Such apps include Messages and Stocks.

Closing Thoughts

I’ll never take for granted the repeated decision over the years by the Apple text system developers to keep supporting the Emacs keybindings. While perhaps not intended, this feature quite seriously is an ecosystem lock-in factor for me. It is a gift and to some extent, a secret handshake, that I’ll always be grateful for. To whoever was, is, or will be involved with keeping this feature alive, thank you.

-1:-- An accidental lock-in feature of the Apple ecosystem (Post Charles Choi)--L0--C0--June 12, 2024 08:25 AM

Irreal: Viper and Evil

Just a quick note to share something that I’m just learning after more than 15 years of using Emacs. I am, of course, aware that Viper and Evil are modes that emulate the Vi family of editors. It’s a way of letting immigrants from Vi/Vim retain their muscle memory while enjoying the superior working environment of Emacs.

I had always assumed that Viper is an older emulation that has since been replaced by Evil. That’s sort of correct but not quite precise. Over at the Emacs subreddit, CorysInTheHouse69 asks why, given that Viper is builtin, people prefer Evil over Viper. The answers surprised me.

It turns out that they actually have different aims. Viper is a Vi emulation while Evil is a Vim emulation. Unless you’re the type of person who prefers the original Vi to the “new-fangled” Vim and its siblings—and there are such folks—you probably want Evil, which offers a very faithful Vim emulation.

As a side note, several of the respondents note that the distinction between built in and third party packages is more political than practical these days. As I wrote the other day, Emacs makes no distinction between code that is built into Emacs and that which is added on. It can not, in fact, tell the difference. It is, as they say, turtles Elisp all the way down.

Regardless, if you, too, were ignorant about the different purposes of Viper and Evil, now you know.

-1:-- Viper and Evil (Post jcs)--L0--C0--June 11, 2024 04:09 PM

Sacha Chua: 2024-06-10 Emacs news

Links from, r/orgmode, r/spacemacs, r/planetemacs, Hacker News,, kbin,, lemmy,,, YouTube, the Emacs NEWS file, Emacs Calendar, and emacs-devel. Thanks to Andrés Ramírez for emacs-devel links. Do you have an Emacs-related link or announcement? Please e-mail me at Thank you!

-1:-- 2024-06-10 Emacs news (Post Sacha Chua)--L0--C0--June 10, 2024 01:01 PM

But She's a Girl: On the 'Emacs From Scratch' cycle

I think that using Emacs is a type of life-long project. It is deep, famously all-encompassing, and there are uncountable interesting rabbit holes to go down and endless tweaking which can be done. It’s exciting and fun, if you like that kind of thing (which I definitely do). Between the bouts of tweaking and honing your editing tool to fit your needs precisely, you get useful and satisfying writing and editing done with it.

However, I don’t think that I’m the only person who cycles through bouts of using one of the big Emacs frameworks (for me, usually Doom Emacs) and configuring Emacs from scratch. Looking back in this blog, my last ‘From Scratch’ cycle was in October of 2021, and before that, October of 2018, so I seem to be on about a 3-year Emacs From Scratch cycle. This — I have come to realise — is The Way of Things, and as natural as the annual migration of salmon to their spawning grounds, or the 13 or 17 year life cycle of some species of cicada. Let me try to explain.

-1:-- On the 'Emacs From Scratch' cycle (Post)--L0--C0--June 09, 2024 03:55 PM

Irreal: Rolling Your Own Syntax

Over at Abstract Heresies, Joe Marshall has a great post on one of the reasons Lisp is such a great family of Languages. I say “family” because there isn’t a single Lisp language. These days, the four main Lisps are Common Lisp, Scheme, Clojure, and Elisp although there are others. I’ve been using all but Clojure for about 20 years. Recently, I do most things in Elisp simply because it’s quick and easy to get something going in Emacs with it.

One of the main sources of Lisp’s power is that Lisp programs are defined in terms of Lisp data structures. Specifically, a Lisp program is a set of nested lists. That’s the source of the well known aphorism that in Lisp, programs are data and data are programs. Marshall’s post looks at another outcome of Lisp programs being data: macros.

Because Lisp programs are data, it’s possible, through macros, to write code at compile time that then becomes part of the program being compiled. A consequence of this is that unlike almost every other language it’s possible to add new syntax to the language. Marshall gives a couple of examples of how easy it is.

Another, less exciting example, that I used to deal with all the time was adding a while construct. One of the Lisps I mentioned above, I no longer remember which, didn’t have a while operator at the time but it was almost trivial to add it in terms of existing constructs. Try doing that in any other language. Even if it’s possible you’re going to have to modify the parser, and perhaps, the lexer and code generator as well.

This capability is why Lisp is called the programmable programming language. The fact that Emacs is written in a Lisp is why it’s fair to describe it—and only it—as a programmable programming editor.

-1:-- Rolling Your Own Syntax (Post jcs)--L0--C0--June 09, 2024 03:31 PM

Gene Goykhman: Always Yes in Emacs Lisp

Always Yes in Emacs Lisp

June 9, 2024

Some Emacs commands tend to ask too many confirmation questions, or at least it would be nice to have the option to skip the confirmation step. For example, saving and quitting a merge session in ediff requires quitting, confirming the quit, and then confirming the save.

I wanted to bind a single keystroke that would unconditionally commit my changes and end ediff. In the process, with the help of a coaching session from Prot, I made a general-purpose wrapper around any Emacs function to bypass confirmation.

(defun always-yes (&rest args)
  (cl-letf (((symbol-function 'yes-or-no-p) #'always)
            ((symbol-function 'y-or-n-p) #'always))
    (funcall-interactively (car args) (cdr args))))

I then used it to bind Q to unconditionally quit ediff, which requires a little more work than other packages typically would:

(defun my/ediff-quit-unconditionally ()
  (always-yes #'ediff-quit))

(defun add-Q-to-ediff-mode-map () (define-key ediff-mode-map "Q" 'my/ediff-quit-unconditionally))
(add-hook 'ediff-keymap-setup-hook 'add-Q-to-ediff-mode-map)

This is a small improvement to be sure, but little quality of life improvements like this accrue over time. It’s one of the things I like most about Emacs.

-1:-- Always Yes in Emacs Lisp (Post)--L0--C0--June 09, 2024 04:00 AM

Jeremy Friesen: Adding a Consult Function for Visualizing Xref

Over the last month, I’ve started working in a rather large code-base. And I’m using the eglot package to help navigate to and from code definitions; under the hood eglot connects into the xref package, a tool for navigating to programatic symbols.

The xref package exposes several functions, creating a bit of a breadcrumb trail:

Find the provided symbol’s definition; usually this is the symbol at point.
Go back to the previously found symbol.
Go forward to the next found symbol; available when you went back.

And on some of my code expeditions, I jump to a definition, then another definition and so forth. It can be easy to lose my place; even as xref tracks where I’ve been.

But to my knowledge, the breadcrumbs aren’t visible…until I wired up a Consult function.

(defvar consult--xref-history nil
  "History for the `consult-recent-xref' results.")

(defun consult-recent-xref (&optional markers)
  "Jump to a marker in MARKERS list (defaults to `xref--history'.

The command supports preview of the currently selected marker position.
The symbol at point is added to the future history."
      (or markers (flatten-list xref--history)))
    :prompt "Go to Xref: "
    :annotate (consult--line-prefix)
    :category 'consult-location
    :sort nil
    :require-match t
    :lookup #'consult--lookup-location
    :history '(:input consult--xref-history)
    :add-history (thing-at-point 'symbol)
    :state (consult--jump-state)))

This function behaves very much like Consult’s consult-mark function; showing a preview of each of those xref locations.

-1:-- Adding a Consult Function for Visualizing Xref (Post Jeremy Friesen ( 09, 2024 02:03 AM

Arialdo Martini: Git fixup is magic (and Magit is too)

We all know how to use git commit --amend to fix up the very last commit.
How beautiful would it be to have a command like:

git commit --amend=3

to extend this power to fix up the 3rd to last — or any other past — commit?

Enter git fixup.


Add this alias to your .gitconfig:

  fixup = "!f() { TARGET=$(git rev-parse $1); git commit --fixup=$TARGET ${@:2} && GIT_SEQUENCE_EDITOR=true git rebase -i --autostash --autosquash $TARGET^; }; f"

Then, use it as follows:

  • Make a change.
  • Stage files with git add .
  • Fix up the desider commit (git fixup <SHA-1>).
  • Profit.

How it works


Some devs are scared by the very notion of rebasing, but in fact a rebase is an embarassingly simple thing: just a series of cherry-picks.

With a tree such as:

* 84831ab  (HEAD -> branch) branch 3
* 65b297f  branch 2
* 66fe73c  branch 1
| * 7208745  (master) five
| * 6f3ab93  four
* 85f4b7e  three
* 7011e1f  two
* 76ec393  one

rebasing branch on top of master with:

git rebase master

is just equivalent to:

git reset --hard master

git cherry-pick 66fe73c  # 1st commit
git cherry-pick 65b297f  # 2nd commit
git cherry-pick 84831ab  # 3rd commit

Interactive rebase

Adding the --interactive flag to git rebase lets you fine tune the series of cherry-picks before their execution.

If instead of the previous:

git rebase master

you run:

git rebase master --interactive

your preferred editor will pop-up, with this content:

pick 66fe73c 1st commit
pick 65b297f 2nd commit
pick 84831ab 3rd commit

This gives you the chance to do all sorts of magic before rebasing, such as

  • re-arranging the cherry-picks in a different order
  • squashing two of them together
  • splitting commits
  • modifying their messages

and the like.
In other words, --interactive creates a transient todo-list file, a little script of commands for Git to execute.

This is the first key to understanding how git fixup works.

Message-based commands

The second key revolves around a little known option of the git rebase command: --autosquash.

As a matter of fact, not only can the user edit the todo-list file, but Git itself also interprets the commit messages in search of commands. This is similar to the functionality often used with GitHub to close an issue by mentioning its number with a special syntax such as #fixes 42 in a commit message.

Indeed, during an interactive rebase:

If a commit message starts with “squash! “, “fixup! “ or “amend! “, the remainder of the subject line is taken as a commit specifier, which matches a previous commit if it matches the subject line or the hash of that commit.

In order to instruct Git to interpret those commands, you shall use the (confusingly named) --autosquash option.

So, the trick for fixing up the 3rd to last commit is to add a new commit with a properly forged message mentioning its message:

pick 3732234 fixup! 3rd commit
pick 66fe73c 1st commit
pick 65b297f 2nd commit
pick 84831ab 3rd commit

and then running an interactive rebase with the --autosquash option.

Letting Git forge the proper commit message

We are almost there. Let’s fine tune this idea. As a matter of fact, you don’t even have to type that message. Just type:

git commit --fixup 84831ab

and Git will diligently copy the 3rd to last commit message, prefixing it with fixup!.

Executing the rebase

Now it’s a matter of executing the interactive rebase, with this magic --autosquash option.
The only outstanding problem is that for this fixup to work, the rebase must be interactive and this is not what you wished: you don’t really want to be asked for any input. You prefer having a git fixup command completing all the necessary tasks without bothering you.

The trick is to use true as the interactive editor.
true is a little tiny program that does nothing, successfully (it takes 80 lines to do so).

Interpreting the alias

This should give you all the ingredients to interpret the alias.
If you are one of those horrible developers who refuse to copy-paste a snippet of code before they really understand it, here’s a breakdown.

Part Meaning
!f() { ... }; f Define a shell function named f; at the end, execute it.
TARGET=$(git rev-parse $1); Get the full commit hash of the target commit, specified in the first Bash argument ($1).
git commit --fixup=$TARGET Create a new commit setting the commit message to fixup! <commit message of the target commit>.
${@:2} Optionally, allows you to pass additional arguments to commit. ${@:2} in Bash refers to all the command line arguments starting from the second one.
&& This is a shell operator that executes the next command only if the previous one succeeded.
GIT_SEQUENCE_EDITOR=true Tell Git to use true as the dummy editor for the interactive rebase. true always succeedes, actually turning the interactive rebase as non-interactive
git rebase Start the rebase…
-i interactively…
--autostash stashing any uncommitted changes before rebasing…
--autosquash squashing the fixup commit into the target commit…
$TARGET^; from the commit before (^) the target commit ($TARGET).

It’s Magit!

Magit, the amazing Git client running on top of Emacs, offers a very convenient way for selecting the past commit to modify. Just make your change. Then, instead of committing on top of the last commit, run magit-commit-instant-fixup and select the commit you want to amend. That simple.

The feeling is like having a non-read-only Git history. So sweet!
If this is not enough, Magit offers a command called magit-rebase-edit-commit that lets you mark a past commit as editable and perform whatever change you desire.

Yes, Magit is magic. But, of course, under the hood, there’s nothing but a simple, fixup rebase.

Enjoy rewriting history!


-1:-- Git fixup is magic (and Magit is too) (Post Arialdo Martini)--L0--C0--June 09, 2024 12:00 AM

Charles Choi: Announcing a plan to change some Casual package names

It’s been wonderful seeing the positive response to the different Casual packages I’ve released over the past several months. That said, despite the amount of preparation I’ve put into these porcelains, there is always room for improvement. One area for improvement in particular is naming.

This post announces a plan to change the names of two packages now published on MELPA:

  • cc-isearch-menu will be renamed to casual-isearch.
  • casual will be renamed to casual-calc.

This will introduce a breaking change to their initialization as their package names will be changed. The new initialization code for them will be:

(require 'casual-isearch)
(define-key isearch-mode-map (kbd "<f2>") #'casual-isearch-tmenu)

(require 'casual-calc)
(define-key calc-mode-map (kbd "C-o") #'casual-calc-tmenu)

Or if you use use-package:

(use-package casual-calc
  :ensure t
  :bind (:map calc-mode-map ("C-o" . #'casual-calc-tmenu)))

(use-package casual-isearch
  :ensure t
  :bind (:map isearch-mode-map ("<f2>" . #'casual-isearch-tmenu)))

Again, existing users of casual or cc-isearch-menu should plan to adjust their initialization files accordingly upon release of their recipes on MELPA. In terms of scheduling, this change should occur on 2024-06-16, provided all goes swimmingly with the MELPA review process.


This leads the way to releasing an upcoming umbrella package (working title is casual-suite) to carry all the Casual packages. With casual-suite installed, any future additions to the suite of porcelains shall be automatically pulled in.

With this organization, the opportunity to consolidate code among the different packages becomes available. This should improve their maintenance and reliability.

At current, roadmap planning for new Casual porcelains is contingent upon the release of casual-suite. Planned for release later this summer are porcelains for:

  • Bookmarks
  • Re-Builder
  • ibuffer

Closing Thoughts

For existing users of cc-isearch-menu and casual, I thank you so very much for your patience and hopefully your understanding with these changes. If you have any questions or thoughts, please share them at this discussion group link. Thanks!

-1:-- Announcing a plan to change some Casual package names (Post Charles Choi)--L0--C0--June 08, 2024 09:45 PM

Kisaragi Hiu: reStructuredText 中文:如何讓連結不要有多餘的空格

reStructuredText 的文內語法周圍需要有空格,但這樣的話中文連結不就必須要有多餘的空格了嗎?(像是 這個 樣子) 我解釋一下為什麼會這樣覺得:Org Mode 的文內語法就是
-1:-- reStructuredText 中文:如何讓連結不要有多餘的空格 (Post Kisaragi Hiu)--L0--C0--June 08, 2024 04:57 PM

James Dyer: Using A Mechanical Keyboard, Literally On A Laptop!

The next stage on my quest to mitigate any RSI issues when using Emacs on a laptop is to see if it is a viable option to use a mechanical keyboard on a laptop.

When I mean “on a laptop” I literally mean ON the laptop!!

My idea is to buy a smallish portable mechanical keyboard and just plonk it (technical term) over my current laptop keyboard.

At the moment I know nothing about mechanical keyboards, I just know from an RSI perspective they are generally a good idea. I do miss the feeling of key travel and I am aware at times I’m tapping too hard on my laptop keyboard due to their shallow depth.

So here is the keyboard in its fully installed glory - extreme plonkification!

I however encountered notable difficulties that depended largely on the placement of the keyboard’s feet in relation to the laptop’s built-in keyboard. Spamming of a single key press was a common issue and was due to my built-in laptop still being enabled when the mech-keyboard was plugged in.

Simply solved however with a bash script to disable the laptop keyboard when the mech is plugged in.

Note: this will be SwayWM specific but can easily be adapted by replacing the swaymsg command.


while :
   if [[ -L "/dev/input/by-id/usb-SEMICO_USB_Gaming_Keyboard-event-kbd" ]]; then
      if [[ $KEYBOARD_CONNECTED == 0 ]]; then
         notify-send -t 3000 "KEYBOARD CONNECTED!"
         swaymsg input 1:1:AT_Translated_Set_2_keyboard events disabled
      if [[ $KEYBOARD_CONNECTED == 1 ]]; then
         notify-send -t 3000 "KEYBOARD DISCONNECTED!"
         swaymsg input 1:1:AT_Translated_Set_2_keyboard events enabled

   sleep 2

Now I can use Emacs on a laptop without the drawbacks of using a shallow laptop keyboard.

The next ergo improvement might now be trying to find a better resting hand position as the new mech-keyboard is raised by an inch or so, but that will be for another ergpost…

-1:-- Using A Mechanical Keyboard, Literally On A Laptop! (Post James Dyer)--L0--C0--June 08, 2024 03:55 PM

Irreal: Scrolling and Font Size Changes in macOS

After my post on a Linux specific problem and Emacs I feel entitled to bring up another macOS specific issue. This problem is brought to us by Alvaro who explains that it’s possible to combine trackpad scrolling and certain keystrokes that result in a spontaneous font size change in the current buffer. Depending on whether you scroll up or down, the font may become larger or smaller.

The font size changes get triggered when Ctrl is pressed while scrolling. It’s tempting to say it serves him right for using the mouse in Emacs but, as Alvaro says, the MacBook trackpad is especially convenient for scrolling and easy to get used to when in one of those other applications. It’s right there below the keys and so easy to reach with a thumb that one can almost pretend they’re not using the mouse.

For a while, Alvaro solved the problem by simply reloading the file with Ctrl+x Ctrl+v but then someone showed him how to stop Emacs from changing the font sizes to begin with. If you’re having this problem, head over to Alvaro’s post to see to solution. Better yet, keep your hands off the trackpad.

-1:-- Scrolling and Font Size Changes in macOS (Post jcs)--L0--C0--June 08, 2024 02:51 PM

Eric MacAdie: 2024-06 Austin Emacs Meetup

There was another meeting a week ago of EmacsATX, the Austin Emacs Meetup group. For this month we had a predetermined topic, but it only lasted for a few minutes. As always, there were mentions of many modes, packages, technologies and websites, some of which I had never heard of before, and some of this ... Read more
-1:-- 2024-06 Austin Emacs Meetup (Post Eric MacAdie)--L0--C0--June 08, 2024 07:35 AM

Isma: The Air Show Interviews Scott Kirby

This week, The Air Show podcast aired an interview with Scott Kirby, CEO of United Airlines. Jon Ostrower from the Air Current has a follow up article on the interview that’s worth reading as well. While appearances like this are not remarkable, it was Kirby’s attitude and his approach to management that made an impression on me.

About Scott Kirby

Corporate portrait of Scott Kirby
United Airlines’ CEO Scott Kirby

One of the things I didn’t know was that he has 7 children. This sounds like a job in and by itself. He also pointed out that he reads for 3 hours per day. Why on earth does he not have a Kirby’s Notes? These two ice-breaking facts caught my interest and set the stage for a fascinating chat.

About United

For those outside the US and not familiar with the topic, United has been known for not being the most passenger-friendly airline and lately, their hiring practices have been put into question, fairly or not.

Lately, United has seen a surge in aircraft maintenance issues that have caught the attention of the safety agencies…. and the safety agencies’ oversight bureau. Even though all these issues appear to be unrelated and don’t show negligence on the airlines’ maintenance practices, it’s still not a good look.

United Today

Picture of a United 787-MAX 8
United 787-MAX 8

While it’s not easy to ignore all these things, this week I was listening to an interview with United’s CEO about the airline, how he’s turning things around, and where it sees itself in the industry.

Kirby goes on to talk about his approach at United. An approach based on innovation and doing things that make the customer want to stick with them: a faster and proactive rebooking system, flights staying at the gate 5 to 10 minutes to wait for connecting flights, or even making a point of keeping the wet towels before departure to foster eye-to-eye contact between the flight attendants and the passengers.

And this hits home. Last year was a terrible year with American for me. This year I have decided to try out Delta and the experience has been fine: Delta One was honestly underwhelming as a product (granted I tried it on an A330 and not on their latest A350 or retrofitted jets), but I still have a fly Delta more to really be able to judge. So far no long delays, although I have a 38-minute layover in Minneapolis coming up and I wonder why I haven’t been rebooked yet.

Depending on how it all goes, I am willing to try out United given what I have heard from the top. Is it true that United is taking a step back and putting customers first?

Boeing Tomorrow

Kirby also talked about Boeing’s struggles, pointing out the fact that Boeing needs a culture change, one that puts its employees at the forefront and that revenue would follow. The way it was before its merger with McDonnell Douglas, where engineers ran the company with innovation with fewer concerns about shareholder value.

I found this fascinating: put your employees (and customers for that matter) first and revenue will follow. I understand what he means, but is it too naive of a position to take? How many “cool startups” that take care of its employees fail each year because of poor leadership? I’m not saying Kirby is wrong, I want him to be right. I want the formula to be right, however, one needs to wonder if the problem is a lot more complex and “happy employees and happy customers” are not enough for the company to be the American source of pride that Boeing used to be.

I believe Boeing’s problems can be solved with a culture change. Over and over again I see technology (or innovation-based) companies being run by MBAs with no engineering background making decisions based on spreadsheets. But Boeing still has time to change its ways. Or at least that’s what the airlines think based on their order books.

Picture of a United Boeing 787 in flight
United Boeing 787

Business and air travel

It’s easy for top executives to say “we need to put safety first”, or “shareholder value needs to build value long term”. But one can’t help but wonder if these are simplistic views that make CEOs look good. I am not a CEO, so I don’t know. But if what they say is true, why do I just get a $50 refund from a major airline that took me to the wrong airport with a 12 hour delay? There is a lot to be learned about customer care.

The post The Air Show Interviews Scott Kirby first appeared on Arenzana.

-1:-- The Air Show Interviews Scott Kirby (Post isma)--L0--C0--June 07, 2024 07:12 PM

Alvaro Ramirez: Hey mouse, dont mess with my Emacs font size

07 June 2024 Hey mouse, don't mess with my Emacs font size

While most of my Emacs workflows are typically keyboard-driven, I'm fairly pragmatic about mouse usage. My MacBook's trackpad is great for just kicking back to read and scroll through text.

There are brief times, however, when that keyboard-driven muscle memory overlaps my mouse usage, resulting in a buffer catastrophe. I joke of course. What I'm actually referring to is nothing more than a slight annoyance. There are times when I inadvertently trigger or events (because I happen to hold Ctrl down while triggering scrolling events). This results in buffer font size quickly changing to either really large or super small, depending on whether I was scrolling up or down at the time. The snafu is further exacerbated by inertial scrolling on trackpads. Go ahead and press the Ctrl key while your buffer is carrying some of that inertia. The font size is affected just the same, even though there was no explicit physical/touching activity on the trackpad at the time.


While this behaviour was a little annoying, I would typically just reopen the file via C-x C-v RET (aka find-alternate-file), which would reset the font size as a convenient side-effect. Now, you may wonder if reopening the file would also forget the point/cursor position, but that's not an issue if you've got the handy built-in save-place-mode turned on (highly recommended).

Ok and all, but this is a second-class workaround at best. What I really wanted is for the mouse/trackpad to stop messing with my font size.

Lucky for me, I bumped into a simple solution shared by Shane Celis and Thanga Ayyanar. It worked a treat, and it's only a few lines of elisp.

(global-set-key (kbd  "") 'ignore)
(global-set-key (kbd  "") 'ignore)
(global-set-key (kbd  "") 'ignore)

Thank you folks. Balance restored.


While I was using C-x C-v RET (aka find-alternate-file) to reset font size, Luke T. Shumaker and Matthew G. shared a better reset alternative:

C-u 0 M-x text-scale-adjust
-1:-- Hey mouse, dont mess with my Emacs font size (Post)--L0--C0--June 07, 2024 05:20 PM

Irreal: D-Bus and Emacs

I have, from time to time, written Emacs posts that are specific to macOS. Lots of folks use macOS so I don’t apologize for that but lots of folks use some flavor of Linux too so it’s only fair to recognize some Linux specific Emacs uses as well.

Lars Ingebrigtsen is a Linux/Emacs user who likes things the way he likes them and who has no patience for systems that don’t meet his needs exactly. He has an interesting post that lists three such problems:

  1. His laptop goes into power save mode sooner than he’d like.
  2. When he closes his laptop cover it goes to sleep like most laptops. He doesn’t like that for reasons you can read in his post. He wants it to turn off his screen and nothing else.
  3. When he turns off his Bluetooth speakers, he wants his laptop to stop playing music.

He noticed that what all these problems have in common is that he wants to react to some hardware event in his own way, not in the way the system developers thought best. His solution to this is to use D-Bus to listen for the requisite events and notify him when they occur. From there, it’s a simple matter to react in the appropriate way.

What may be surprising is that all this is written in Elisp. He doesn’t show the code in the post but does provide a link to it. The code is straightforward and there’s not much of it. It is, as he says, specific to his needs but should be easy to adopt to any user’s needs.

Sadly, this is mostly useful for Linux users although there is a port of D-Bus for macOS. I’ve never used it so I don’t know how well it would work for an application like this but it’s easy to install with Homebrew and worth checking out if you have problems similar to Ingebrigtsen’s.

-1:-- D-Bus and Emacs (Post jcs)--L0--C0--June 07, 2024 04:24 PM

Christian Tietze: Fold Search Results Away in rg.el

With the power of outline-minor-mode in Emacs, you can turn any text buffer into an outline – with the killer feature of “cycling”, i.e. folding and unfolding outline elements.

This includes rg.el-managed buffers, search results powered by ripgrep.

Update 2024-06-07: I changed the approach to a more robust regex! The form-feed insertion actually broke result navigation. compilation-next-error in turn would expect not to find a form-feed character at the start of a line. Working around that was more trouble.

To tell rg.el buffers which line is a ‘heading’ in terms of outline-minor-mode, change the regular expression to match each line beginning with "File:":

(defun ct/rg-folding ()
  "Enable outline-minor-mode on file entries in rg.el results."
  (setq-local outline-regexp "^File: ")
  (outline-minor-mode t))
(define-key rg-mode-map (kbd "<tab>") #'outline-cycle)

With that, you can run a search and zoom out to all files via M-x outline-hide-sublevels and then zoom into each with a tab.

Note that even though outline-regexp’s documentation says that we can assume we’re at the beginning of a line etc., omitting the ^ to denote the start of a line produces wonky results: it will fold, but sometimes, it would fold too much. I had file entries further down the buffer be folded away, too, and outline-hide-sublevels would hide the complete buffer.

My Previous Attempt That Is Actually Broken: Inserting a Form Feed

The default outline-regexp value contains the form-feed character. That gave me ideas

I now decorate all "File:" lines, prepending a form-feed character:

;;; Warning: this breaks navigation in result buffers!
(defun ct/rg-add-form-feed ()
  "Prepend a form feed character to all file match lines."
    (goto-char (point-max))
    (while (re-search-backward "^File: ")
      (goto-char (match-beginning 0))
      (insert "�\n"))))
;; Do not add the hook to a broken function! :) 
; (add-hook 'rg-filter-hook #'ct/rg-add-form-feed)

You can enter a literal Unicode 0x0C FORM FEED (FF) character in Emacs by typing C-q C-l. I did that. But that doesn’t render well on the blog, so the code uses Unicode escape sequences. (You could also use "\f" I learned later!)

Form-feed lines between results, with the topmost ones folded away

I do render my form-feeds as lines, by the way. Check out form-feed-mode; the code from my init file is:

(use-package form-feed
   '(form-feed-include-modes '(prog-mode text-mode help-mode compilation-mode org-mode)))
  (global-form-feed-mode +1))

Hire me for freelance macOS/iOS work and consulting.

Buy my apps.

Receive new posts via email.

-1:-- Fold Search Results Away in rg.el (Post)--L0--C0--June 07, 2024 03:38 PM

Isma: Shows I’m Digging – June 2024 Edition

I’m in a California Millennial type of mood lately and the shows that I’ve been watching reflect it. Just kidding, I guess I was a Californian in a previous life.

In an effort to “grow” in my areas of interest, I have added a film photography channel and a “cooking channel” to my Youtube subs. The use of double quotes is called for.

Back to Film

As indicated in my previous post, I have been going back to film. Unfortunately, my Leica M6 is back in Spain waiting for me, so I’m making good use of an Olympus 35SP rangefinder I found on eBay for a decent price. My plan right now is not to develop the film like I used to or even to scan it. At least not for now. Let the pros do that!


Caleb and Jason discuss film photography in Mamiyamigos. I enjoy watching friends discuss their passions, like when El Mentidero was going on. The problem with this show is that I will surely end up spending more money than I should in photography gear. It’s the price to pay (no pun intended).

Bourdain would be proud

Contrary to what it may seem in practice, cooking is another one of my interests. Particularly unhealthy dishes.

For a few years I’ve been watching Sam the Cooking Guy, which I have been enjoying. I have learned quite a bit about amounts, avocado oil, and how to time things. He has also helped me understand patterns in American fast food-making.

Just recently, however, I found out that his sons have their own channel, Sons of Sam the Cooking guy.. The twist of this show is that Sam’s sons can’t cook. So they try to recreate some of his dad’s dishes with different degrees of success. Half foodie goodness, half comedy.

The post Shows I’m Digging – June 2024 Edition first appeared on Arenzana.

-1:-- Shows I’m Digging – June 2024 Edition (Post isma)--L0--C0--June 06, 2024 09:00 PM

Irreal: Some Great Emacs Packages

Over at Lambda Land, Ashton Wiersdorf opines on what he considers the best Emacs packages. You may agree or disagree with any particular choice in his list but it’s hard to argue that his choices are not reasonable.

His list starts with Magit, Org Mode, and Avy, which should, in my opinion, be on everyone’s top 5 (or so) list but that’s low hanging fruit. Next on his list is Embark, Eat, and Jinx. I use Embark and like it but it’s not a must have for me. I really liked the idea of eat, but after I installed it, I never used it so it was a dud for me. One of the things everyone loves about it is how fast it is but the speed of all the Emacs terminal emulators seem fine to me. I’m not familiar with Jinx but it seems like it’s something worth checking out.

His next three packages are Vertico, Consult, and Corfu. I don’t use any of these. I much prefer the Swiper/Ivy/Counsel package. It does pretty much the same things and I’m used to and happy with it so I’m not inclined to change.

Regardless of my predilections, these are great packages and worth taking a look at to see if they would work for you.

-1:-- Some Great Emacs Packages (Post jcs)--L0--C0--June 06, 2024 03:52 PM

Mario Jason Braganza: Note to Self, Linking to a Headline in an Org File

I did one of those periodic, empty your mind sessions today.
Everything is now in a brain dump org file.
And now, like a every good productivity system preaches, I want to review the dump periodically.
There is a task for my miscellenea for e.g. Could I convert it to a link and have it open the file at that precise location?
Turns out Org Mode links let me do just that.
All I need to do, is first store a link in Org parlance. I do that by going to my target file that has the dump (the bottom file in the screenshot), go to the section that I need linking to (in my case, Misc Brain Dump), and hit C-c l

After which I go to the file which needs to contain my link, and select my text that I’ll want converted into a link (inserting a link in org speak. In my case, the top file in the screenshot below).
I select the Misc Brain Dump part of the “Look at the Misc Brain Dump” task and hit
C-c C-l
It then switches me to a buffer that shows the links that Org currently has stored, with the minibuffer prompting me to choose one

I use the arrow keys to choose the one I want, hit return and it creates the link for me.

Here, I’ve switched away from my brain dump. (I’ve closed the file in fact)

I click the link in my tasks file and …

It opens right up, at the exact location I want. Woohoo!

And just like everything else with Org, it’s plain, simple, elegant, text functionality.
I examined the link and it was a borg standard Org link, with the link having the header tacked on the end, like so …*Misc Brain Dump1

Feedback on this post? Mail me at feedback at this domain

P.S. Subscribe to my mailing list!
Forward these posts and letters to your friends and get them to subscribe!
P.P.S. Feed my insatiable reading habit.

  1. which should have been evident when I chose the link to insert, but I only saw it and went Aha! much later 😂 ↩︎

-1:-- Note to Self, Linking to a Headline in an Org File (Post)--L0--C0--June 06, 2024 12:01 PM

Irreal: Casual Info

Charles Choi is back with another of his “Casual” packages. This time it’s for what some of us consider the the dumpster fire that is Info1. His latest offering, Casual Info, provides a porcelain for Info that not only provides a menu for Info but also rationalizes some of the keystrokes.

As Choi says, most users probably expect Info to behave more or less like a Web browser, yet Info is almost perverse in its choice of UI. To be fair, the Info interface was fixed long before Web browsers were popular but almost everyone is going to find it disconcerting. That’s why Choi changed some of the bindings on his interface.

Alphapapa suggested that since Transient is now an Emacs builtin, Choi should offer his various Casual packages as part of vanilla Emacs. That makes a bit of sense. All of them help with the use of Emacs functionalities that have hard to remember bindings and would be a boon to not just n00bs but even more experienced folks like me who have trouble remembering seldom used bindings.

Choi seemed open to the suggestion. My opinion is that they’re a worthy addition but it doesn’t really matter. If you want them, they’re easily available from MELPA. Having them in core might, I suppose, aid discoverability. Regardless, I certainly wouldn’t object to their inclusion.

If you, too, find the Info interface maddening, take a look at Choi’s post for an alternative. Perhaps it will one day be built in but regardless MELPA is only a couple of keystrokes away.



“Dumpster fire” is probably too harsh but it’s certainly fair to say that its user interface is less than optimal.

-1:-- Casual Info (Post jcs)--L0--C0--June 05, 2024 03:00 PM

Zachary Kanfer: Less: a Survival Guide

I noticed recently that I was having trouble moving around in less. I could arrow up and down, but that took a lot of work. I could hit space to go a whole screen down, but unlike in a web browser, shift-space also scrolls down. How could I scroll up a screen? On some terminals, Page Up and Page Down work, but not in others.

It's a confusing mess.

So, after years and years of using less, I finally looked up how to move around natively. Native less commands will work everywhere! Here's the most useful things I found. As a bonus, I also ran into some ways to configure less to be more helpful!

General less commands


Open a summary of less commands and options.

q or =ZZ

quit less. This isn't exactly navigation, but is pretty important.


These commands move around in the output.

up, down

Move a single line up or down.

left, right

Move a half screen left or right.


Move forward (down) a whole screen.


Move backward (up) a whole screen.


Move down half a screen.


Move up half a screen.

g or <

Go to the beginning of the output.

G or >

Go to the end of the output.

They also work with the control modifier, if for some reason you want to press more keys.

I've been finding that d and u are pretty easy to remember, but a lot of the other ones are more difficult. Some of the commands are taken from vi, so if you already know vi, that helps.


When I'm using less, there's generally a lot of text. Fortunately, less lets you search in the text it's displaying!


Begin a search. Type your query, then press return to jump to the next result.


Go to the next match for the search.


Go to the previous match for the search.


Less is actually configurable! Here are some command line options. If you prefer – perhaps because less has been spawned from another program – they can also be typed once less is running.


Toggle case sensitivity for searching, unless the search query contains capital letters.


Put a marker on the left edge of the screen on every line that the current search matches.


After a forward jump of more than one line, highlight the first new line. Unfortunately, this doesn't work for jumping backwards.


When a line is marked (as with -W), mark the whole line instead.


Start searching as soon as you start typing the search query.


Use color in less's output!


Output incoming escape characters in raw form. This helps when the input contains these control characters, like when running git diff or a similar command.

Enabling options permanently

The settings can be set in an environmental variable LESS.

For example, if you're using bash, you might add this to your ~/.profile:

export LESS="-J -i -W --status-line --incsearch --use-color -R"

Or, for Fish shell, run this command:

set -Ux LESS "-J -i -W --status-line --incsearch --use-color -R"

I set them in my shell, and now everywhere I use less, it works the way I want it to work. More or less.

-1:-- Less: a Survival Guide (Post)--L0--C0--June 05, 2024 05:00 AM

Irreal: TABs or Spaces

No, I’m not going to relitigate one of our favorite holy wars. Really, I don’t care very much about the issue. Long ago, I arbitrarily settled on spaces but don’t have strong feelings one way or the other and would change in an instant if there were a good reason.

Still, lots of people do care and chansey97 over at the Emacs subreddit wants to know what people think. The main way you express your preference in Emacs is with the indent-tabs-mode variable. If it’s t TABs get used, otherwise only spaces are used. There are some finer adjustments possible but indent-tabs-mode is the important setting.

To my surprise, most of the respondents echoed my indifference. They basically said that they just want Emacs to do the right thing when they press the TAB key. That’s actually pretty reasonable because the major modes will do the right thing—or whatever you’ve configured—when you press TAB.

Happily, your choice doesn’t commit you to one or the other for every file. For example, I have an old file—dating from my Vim days—that has TAB delimited fields. At the top of that file I simply added

# -*- Mode: text; indent-tabs-mode: t -*-

and when I press TAB, an actual TAB character is inserted.

I don’t know what other editors do. I don’t even remember how Vim handles the situation. It’s enough to know that whatever your preference, Emacs has you covered.

-1:-- TABs or Spaces (Post jcs)--L0--C0--June 04, 2024 03:58 PM

Lars Ingebrigtsen: Using Emacs to Monitor Dbus

Sure, sure, I make problems for myself by insisting on having things “just right”… for me. This blog post is about trying to fix those self made problems.

OK, thing the first:

See that “Turn on power saver mode when battery power is low” thing? Yes, indeed, it’s an on/off toggle: You’re not allowed to specify what “low” is. You used to be able to do that in Gnome Shell, but that was apparently not user friendly enough. (For all I know, perhaps you’re still allowed to do that somehow, but google didn’t help.)

It turns out that this is 20%, which I guess is a reasonable value… IF YOU”RE CHICKENSHIT! When the machine is in “power saver mode”, you can basically not use it normally (it dims the screen after a couple seconds of inactivity etc and nags at you), so you’re giving up one fifth of your effective battery capacity.

So for years, I’ve just switched it off, and if I forget to notice the battery indicator has counted down to 0%, well, then the machine switches itself off in the middle of me typing something.

Thing the second:

When I close the lid of the laptop, I don’t want anything to happen (except switching the screen off). In particular, I don’t want the machine to go to sleep, because I normally have several network connections up, and I don’t want those to be lost willy nilly.

That is, I close the lid routinely to move around and futz around in general, and I don’t want that to be disruptive in any way — and I certainly don’t want to be one of those people that walk around with a half-open laptop! The horrors!

(Our model is here demonstrating the proper way to hold a laptop while walking around.)

The lid action used to be handled by the desktop environment, but in their infinite wisdom, this (as most everything else) has moved to systemd:


And this… makes the laptop ignore me closing the lid. And ignore means ignore — it doesn’t switch the screen off, either!

I mean, it’s not a catastrophe, but…

Finally, thing the third:

Since 1997, I’ve used an Emacs-based music player. (Three decade anniversary coming up soon!) I use it at home, of course, but I also use it while travelling, and that’s the problem. Because when I’m in hotel rooms, it’s sooo annoying to have to switch whatever bluetooth speaker I’m using on, and then open the laptop, find Emacs, and press z (for unpause). And then when going out, it’s the same thing, only in reverse! This cannot stand! It’s an outrage!

So I thought… all these things have in common that they are events that I want to react to, but in my own way. What would be an easy way to detect these events?

Well, there’s Dbus.

dbus-monitor --system certainly says that there’s a lot of information passing over that bus, so perhaps that’s all I need?

So I looked at the Emacs Dbus documentation… and that sounds promising. And the documentation in my somewhat older Emacs says:

dbus-register-signal is a byte-compiled Lisp function in dbus.el.


Register for a signal on the D-Bus BUS.


SERVICE, PATH, INTERFACE and SIGNAL can be nil.  This is
interpreted as a wildcard for the respective argument.

OK, and I just want (as a first step) just to see what data is available, so since all those things can be wildcards, this should work, right?

(defun my-signal-handler (device)
  (message "Device %s added" device))

 :system nil nil nil nil #'my-signal-handler)

But nope, total silence. And google shows me nothing, of course, because Google. I’ve been experimenting lately with using ChatGPT for somewhat vague questions like this, so I asked, and it gave me the same basic solution:

Which doesn’t work, either.

Now, I haven’t kept up with Emacs development, so I have no idea whether this has been fixed by now, but I looked at the source code in my Emacs, and:

Hey! The handlers are registered in a hash table! There’s no wildcarding for the interface and signal parameters!

And with that, I whipped up a little package (that you can find on Microsoft Github) that allows you to conveniently look at the Dbus properties that change:

Etc etc. And… tada! All the info for all my three problems is available!

So now 1) my laptops dims the screen when there’s 5% battery power left (livin’ on the edge), 2) switches off the screen when I close the lid, and 3) stops playing music when I switch off the bluetooth speaker (and switches the music back on again when I switch the speaker on).

Success! Everything is indeed possible if you have Emacs.

Now, the package on Microsoft Github can’t be used as is by anybody, because it’s so dependent on what your environment looks like. But I think it’s structured in a way that you can trivially tinker with it. So if you have any similar odd configuration issues (because you’ve got strange requirements), have at it.

-1:-- Using Emacs to Monitor Dbus (Post larsmagne23)--L0--C0--June 04, 2024 01:04 PM

Charles Choi: Announcing Casual Info

Announcing Casual Info, an opinionated porcelain for the Emacs Info reader, now published on MELPA. For folks who find the Info reader barely tolerable, Casual Info might make you learn to love it.


My history with the Emacs Info reader is a begrudging, complicated one. When I first started using Info, I’d often be negatively surprised by it, so much so that I’d routinely use the web instead. Upon reflection, I think the reasons for my surprise were:

  1. I didn’t want to RTFM for Info, I just wanted to focus on the content Info was providing. (Inertia is human.)
  2. I expected Info to behave like a web browser. (It kinda does, until it doesn’t.)
  3. Info’s default keybindings muddles in-buffer navigation with node (web analog: page) navigation. (Looking at you n for info-next and p for info-prev.)
  4. Info’s default keybindings for history navigation (l for left, r for right) are unexpected given the typical keys Emacs uses for navigation (f, b, n, p, {, }, [, ]).
  5. Search in Info is very structured whereas my expectations for search is influenced from the web: I expect unstructured searches to work.
  6. I could never recall the bindings for Directory (d), much less History (L). Intermittently I could recall how to get to Top (t) and the Table of Contents (T).


An indifferent reader might think, “well, just learn Info”, which for other tools I would sympathize. But for the Info reader, I think its ideal user experience (UX) should require no learning curve. As many Emacs users prefer keyboard-driven workflows, building a keyboard-based menu seemed ideal to organize Info commands for discovery and recall. So begat Casual Info.

Casual Info UX Design Notes

Navigation Bindings

The Info reader offers many different ways to navigate which is both a blessing and a curse. Info offers no less than six ways to navigate:

  • By reference (Info-prev-reference, Info-next-reference)

  • By peer node (Info-prev, Info-next)

  • By all nodes (Info-backward-node, Info-forward-node)

  • To first and last node (Info-top-node, Info-final-node)

  • Up to parent node (Info-up)

  • By history (Info-history-back, Info-history-forward)

Comprehending these choices, much less learning and recalling them is a steep curve for lay users of Info. Organizing the navigation commands into a menu can help ensure that the desired action is correctly taken. Note that if Unicode symbols are enabled via the Casual Info Settings, then audio/video playback glyphs are used as menu labels to express intent.

I’d assert that most users lay to Info are conditioned to web browser behavior and will expect node navigation to be primarily historical. As such, Casual Info uses the web browser keybinding convention of (M-[, M-]) for historical node navigation instead of the more arcane defaults of l and r.

Another assertion is that Emacs user expectations for p and n are for in-buffer navigation with that buffer’s existing content. I find it bewildering that the default Info behavior is to map p and n to node navigation where the buffer’s content is replaced. To avoid this, Casual Info remaps p and n to paragraph navigation optimized for browsing.

Finally reference (or link) navigation in Casual Info are bound to the vi-influenced bindings j and k.

Bookmarks and Buffers

When reading documentation, it is natural to want to set and jump to a bookmark. So, Casual Info provides these commands. If multiple Info buffers are cloned, then the need to manage them becomes natural as well. So is added support to call ibuffer from the “List buffers” menu item.

Closing Thoughts

Casual Info endeavors to make the Info reader be a less surprising tool to use. Since its creation, I’ve found myself using Info far more frequently and have discovered some particular benefits for doing so:

  • Comfortable access to other tool documentation (primarily GNU).

    If you rely on Bash, GNU Make, and the GNU coreutils, having access to their documentation from Emacs (especially with bookmarks!) is a capability you’ll never want to go without.

  • Offline (aka local-first) usage.

    Viewed from the lens of the web, there is comfort in not having to rely on an internet connection to get reference documentation.

If you've made it to here, thanks for reading! I invite you to please try Casual Info out and provide your feedback on its discussion group.


For readers interested in unifying the UX for the different documentation modes in Emacs, I recommend my post Personalizing Emacs Doc Navigation .

-1:-- Announcing Casual Info (Post Charles Choi)--L0--C0--June 03, 2024 06:00 PM

Sacha Chua: 2024-06-03 Emacs news

Links from, r/orgmode, r/spacemacs, r/planetemacs, Hacker News,, kbin,, lemmy,,, YouTube, the Emacs NEWS file, Emacs Calendar, and emacs-devel. Thanks to Andrés Ramírez for emacs-devel links. Do you have an Emacs-related link or announcement? Please e-mail me at Thank you!

-1:-- 2024-06-03 Emacs news (Post Sacha Chua)--L0--C0--June 03, 2024 05:40 PM

Irreal: A Flush-lines Example

I’m fond of telling stories about folks using Emacs to solve difficult—or at least complicated—problems but Emacs is probably used more often to solve simple, one-off problems. These problems typically don’t require anything fancier than, maybe, keyboard macros.

Mario Jason Braganza has a nice case in point. The TL;DR is that he made a bulk purchase of comics and wondered how many he got. The site that he bought them from had all the information about the purchase but it included much more than just the titles. Each bit of information was on a separate line and Braganza decided to count just the title lines to see how many comics he had.

So Braganza downloaded the information and pasted it into Emacs. He thought that if he could get rid of the extraneous lines, he could simply do a line count to calculate the total number of comics he had bought.

Experienced Emacers are jumping up and down yelling, “I know, I know”. The answer, of course, was flush-lines. You simply call flush-lines, give it a regular expression, and Emacs deletes any lines having a match for the regex. Braganza could, of course, have given it a complicated regex that got rid of all the unneeded lines at once but he chose the simpler—and probably more rational—method of eliminating one type of line at a time. In the end, he had only titles left and a simple line count gave him his answer.

This is, to be sure, a trivial example but it illustrates nicely one of the areas where Emacs shines: simple one-off tasks that would be tedious without the editing power of Emacs. Could you do this in some other editor? Maybe, but why should we care. It works in Emacs and that’s all we need to know.

-1:-- A Flush-lines Example (Post jcs)--L0--C0--June 03, 2024 03:23 PM

Irreal: Emacs As Crack

Jack Baty has a very amusing, but true, take on using Emacs and how resisting it is like resisting gravity: in the end you’re gonna lose. His story is that he hates futzing around with things, especially his Emacs configuration, so every once in a while he decides to find simpler apps to perform all the chores that he does in Emacs.

It never ends well. He starts out loving the new apps and not having to constantly tweak their configuration but he inevitably finds himself missing some of the custom tweaks that he made to Emacs. Then one day, he needs to work on an Org file, opens it in Emacs, and suddenly he’s right back where he started. He rediscovers all those customizations he made to Emacs that made his life so much easier.

It’s like the Borg: resistance is futile … , or perhaps like crack: once you start, you can’t stop. Of course, unlike the Borg and crack, Emacs is not evil—users of those other editors notwithstanding—but a real boon to our workflow. Still, there’s no denying that its use is addictive. Once you start you soon find yourself wondering how you can import this or that task into Emacs. Before long, having to leave Emacs is an imposition. Finally, like me, you find yourself installing emacs-everywhere so that even when you’re not in Emacs, you can be in Emacs.

So rather than the Borg or crack, Emacs is actually the editor for all seasons.

-1:-- Emacs As Crack (Post jcs)--L0--C0--June 02, 2024 03:29 PM

Isma: Writing


For the last few days, I have been experimenting with different writing tools: IA Writer, Ulysses, and Emacs. As you know, I am an avid emacs user for everything from programming, to reading my RSS feeds, and even email. This week, however, I have ventured out to look at other writing tools for my blog. The trigger was DHH’s article on living with more than one computer (more on this later).

Why? You might ask. My iPad is NOT a great tool when it comes to open source software. And by “great”, I mean that it’s not as straight forward as I’d like it to be. Sure, you could install a terminal emulator like iSH, and then install emacs inside, but how do we figure out the filesystem? (yes, I know, Apple limitation). But the temptation of simpler is too powerful sometimes and I have been bitten by the bug of trying something new. What can I say, we all like shiny new things.

Initial thoughts

I’m writing this on iA Writer on MacOS. I love that I can either use iCloud or Dropbox to sync the documents and keep writing on my iPad using my keyboard on the go. Yes, this does happen often enough for me to justify the effort. To export it, I do use a bit of git magic and run a script on the server to deploy. Not the easiest but not the hardest either. My new photography blog is running on WordPress. Both iA Writer and Ulysses (and for that matter emacs) can directly publish to WordPress, which is nice. But I’m not convinced that I want to move back to this platform for my personal blog. At least not yet.

The nice thing about iA Writer is that it’s a one time payment. That’s it. Yes, you do need to pay per platform, but you don’t need to upgrade if you don’t make enough use of the tool. Ulysses, however, is a subscription ($39.99 as of this writing). All platforms. I tend to favor one-time payments rather than subscriptions, this is a con against Ulysses.

When it comes to platforms, iA Writer has a slight edge here, because it supports Windows and Android (separate purchases) in addition to Apple platforms. Neither app supports Linux. Ulysses only supports Apple platforms. I don’t want to close myself to any platforms, as I have been doing more on Windows lately. I have realized that as long as I can share a keyboard, sync my documents, and have a few common applications, it’s not hard to live in Windows (here comes all the hate now). As long as I don’t have to do much terminal work (thankfully there’s WSL) or Windows sysadmin type of things, I feel good.

That being said, I will keep test-driving both apps and perhaps come back with another review. Why do I make no promises? What can I say, I have commitment issues.

The post Writing first appeared on Arenzana.

-1:-- Writing (Post isma)--L0--C0--June 01, 2024 10:00 PM

Irreal: De-Googling: My Secret Weapons

Neeraj Adhikari has a nice post on one of my favorite crusades: banishing Google from my life. I’ve been pretty successful at this because of two thing: Emacs and macOS.

Most longtime readers know that the Irreal empire mostly runs on an Apple substrata. Even so, I’m not really a fanboy because, let’s face it, Apple can be annoying and their fanboys even more so. Still, I do think their hardware is usually best in class and their integration across devices exceeds what Linux/Android is able to do because they control the hardware as well as the software.

To see what this has to do with de-Googling, let’s take a look at Adhikari’s post. He lists several categories of services that he’s managed to find non-google alternatives for.

You can read Adhikari’s post for his replacements but happily for me, Emacs and macOS have me covered. All my email flows through my Apple account. Apple’s not (at least not yet) interested in harvesting my information so they don’t bother scanning my email. Apple also doesn’t insist that I use their mail app. I read and send my email from Emacs with mu4e. And I can still read and send email with the mail app if I’m on my iPhone or iPad.
None of you, believe me, would be interested in seeing my photos so I’m not much concerned with efficient sharing. For the few that I do want to share, iCloud does the job nicely for my needs. The Apple Photos app takes care of curating my photos, syncing them across my devices, and backing them up to iCloud.
External Drive
Again, iCloud works well for me. It’s not expensive, reasonably reliable, and can be accessed from any of my devices as well as from a browser on any device. It’s probably not so good for collaborative work but that’s not a problem for me.
Calendar and Contacts
Again, Emacs and macOS are excellent alternatives. I use both Emacs and macOS for these functions and although it’s possible to sync between them, I don’t bother because I use them on disjoint data.
Let’s face it, if your Google-free life includes not using an Android phone, there is really only one alternative. Anything other than an iPhone or Android phone is simply a non-starter these days.
Although opinion varies, many informed folks say that Apple maps are as good or better than Google maps at this point. I haven’t bothered checking because I don’t care. I use Apple maps almost every day and have never had a problem with them. I use them in my car with Car play and on my Apple devices through the Maps app. I haven’t used Google maps in years.

That leaves Web search and videos. Web search is easy. I use Duck Duck Go and have for years. For a long time it was probably not as good as Google search but from everything I read, Google search has become a dumpster fire lately so Duck Duck Go is not only a good choice but arguably a better one.

Finally, the spoiler: Videos. YouTube continues to be the only realistic choice and is, in fact, the sole Google product used in the Irreal bunker.

So the takeaway is that if you want to live a Google-free life, macOS and Emacs are good places to start.

-1:-- De-Googling: My Secret Weapons (Post jcs)--L0--C0--June 01, 2024 03:47 PM

Jack Baty: The gravitational pull of Emacs

The gravitational pull of Emacs

I want things to be simple and without distraction. I want to avoid futzing all the time. To this end, I often try to move away from using Emacs for everything. Emacs is not simple, no matter how hard I try to force it to be simple.

So I pull out the usual inventory of simple writing and note-taking apps, trying to make them fit. Telling myself that this is better for me.

I spend time actually using all those beautiful and simple apps. I love them, and the whole thing starts out with feelings of excitement and relief from the urge to tweak things in Emacs. Everything seems easier. My pinky is relieved. Futzing is reduced to nearly zero.

However, it&aposs not long before I begin to miss the things I&aposd spent years building for myself in Emacs. I miss Org-mode. I miss Dired and Magit and Howm and Denote. I miss the ridiculously flexible and powerful export features. I miss using something that feels like it was made just for me. Something free and that I have complete control over.

I soon forget about all the time I&aposd wasted spent futzing with init.el or writing little lisp functions to do some silly and likely unnecessary thing that I love.

Then I&aposll find myself needing to open an old .org file. I launch Emacs, and I&aposm suddenly faced with my familiar, comfortable editor. After getting what I need from that .org file, I open my org-agenda just to see what I might have missed. Then I clean up my ~/Desktop folder quickly using Dired. You know, while I&aposm there.

It occurs to me that I might have been premature in moving away from Emacs 😆. I can feel it happening again: the return. I create a new org-journal entry, just for the hell of it. These entries usually begin with something like, "Uh oh! What I&aposm I even doing back here?!" It feels familiar. Feels like home.

One hardly notices the feeling of being sucked back into using Emacs. It just happens. It&aposs like gravity. And you&aposre simply there again.

The gravitational pull of Emacs
-1:-- The gravitational pull of Emacs (Post Jack Baty)--L0--C0--June 01, 2024 12:09 PM

Kisaragi Hiu: Monthly review for May 2024

This month I spent 32 hours on translation (22 of which are for KDE), and 30 hours on development. Open source contributions Shiki: add support for Vala, Genie, QML, QSS, qmldir, Haxe, HXML, Wikitext, Soy (shikijs/textmate-grammar-themes#54) Shiki: add support for Emacs Lisp via Alhadis/language-emacs-lisp (shikijs/textmate-grammar-themes#56) Fix code links being indistinguishable from non-link inline code in Remix docs (remix-run/remix-website#262). This was a case of CSS specificity being a little unintuitive. I plan to file a PR for reactrouter.
-1:-- Monthly review for May 2024 (Post Kisaragi Hiu)--L0--C0--June 01, 2024 10:36 AM

Irreal: 🥩 Red Meat Friday: Emacs Doesn’t Have Plugins

Note: I’m calling this a Red Meat Friday post because of the pushback I got the last time I broached the subject. It’s not really all that controversial.

Over at the Emacs subreddit TheTwelveYearOld asks what makes Emacs and Lisp so special when they’re used together. The answers are interesting but what struck me the most was the role that Elisp plays in Emacs. It’s not something that was tacked on later on: it’s what Emacs itself is built from.

Five years ago I was feeling grumpy and complained about the term “plugin” being used to describe Emacs extensions. I got a bit of pushback. Just because we Emacsers prefer “Package” or “Extension” doesn’t mean that “plugin” is a bad choice, they said. But it is. The word plugin, as commonly understood, refers to code that uses a predefined API provided by the host program that allows users to add limited functionality. Elisp is not at all like that. It’s not just the same language that Emacs itself is written in; the code you write lives in the same environment as the builtin Emacs code. It’s indistinguishable from the code the editor ships with. In fact, packages can be and sometimes are moved into Emacs core virtually unchanged.

Contrast this with other editors that allow you to write plugins in Lua, Javascript, or whatever. The code you write for them are plugins because they can do only what the API allows. You can’t change basic functionality or improve the algorithms the base editor provides.

At the end of the day, Emacs is—as I always say—a Lisp machine. Virtually everything in the system, except a bit of C code, is accessible to the user at run time. There’s no need to edit and recompile. You just change the running image on the fly. It doesn’t have plugins because it doesn’t need them.

-1:-- 🥩 Red Meat Friday: Emacs Doesn’t Have Plugins (Post jcs)--L0--C0--May 31, 2024 04:57 PM

Irreal: Emacs For PhD Students

Over at the Emacs subreddit, InstinctsInFlow says that he’s a PhD student in computer engineering who has been using Emacs for a couple of years because of its support for VHDL coding. He really likes Emacs and want to find better ways of using it so he asked for advice on using Emacs as a PhD student.

I found the answers in the comments to be particularly useful. InstinctsInFlow does his coding in Python so he was particularly interested in how to use Emacs with Python in an optimal manner. Everyone has an opinion on this, it seems, but the suggestions were all good.

The other thing that almost everyone mentioned was, of course, Org mode. If you’re a PhD student, you’re going to be doing a lot of writing. Writing that’s apt to include a bunch of mathematics and there are really only two choices1: Org mode or LaTeX. It’s certainly true that LaTeX gives you finer control but not much finer and in almost all cases Org is fine and it’s always easier.

There are some other good recommendations. If you’re interested in using Emacs for your PhD studies, take a look at the post. It’s short and has some good suggestions.



Sorry, Word is a non-starter in the Irreal universe.

-1:-- Emacs For PhD Students (Post jcs)--L0--C0--May 30, 2024 04:07 PM

Lambda Land: My Top Emacs Packages

If you ask anyone what the best Emacs packages are, you’ll almost definitely hear Magit (the only Git porcelain worth using) and Org Mode (a way to organize anything and everything in plain text) listed as #1 and #2. And they’re right! I use those packages extensively every day.

Besides those two powerhouses, there are a handful of packages that make using Emacs a delight. If I had to ever use something else, I would miss these packages most:

  • Avy

    Jump around your screen crazy fast. Teleport to any character with ~5 key strokes. See for more reasons why it’s awesome. I almost exclusively rely on avy-goto-char-timer and have it bound to s-j.

  • Embark

    Kind of like a super-charged right-click for Emacs. Works beautifully in dired, when selecting files in the minibuffer. There’s an easy way to make it play well with Avy which is just the best.

  • Eat

    Eat is a terminal emulator that’s faster almost all1 the other terminal emulators for Emacs. Additionally, it can make a terminal emulator in a particular region, so if you use Eshell, you can get a little terminal emulator for every command you run. Normally, if you run, say, cal, you see the ugly terminal escape characters printed as text. With Eat, however, those terminal escape characters get interpreted correctly. Interactive programs (e.g. the Julia and Elixir REPLs) work flawlessly with it.

  • Jinx

    Best spellchecking ever. It can spellcheck based off of the fontlock face; I keep this on when I program to get on-the-fly spellchecking of code comments and strings. I keep jinx-correct bound to C-; à la flyspell because it is so darn helpful. Supports checking documents with mixed languages. This is one of the packages I miss most when I’m editing text outside of Emacs.

  • Citar The best way to add citations in Emacs, hands-down. Reads bibtex, inserts in org-mode, LaTeX, whatever.

User interface enhancement #

These next packages are all by Daniel Mendler. These packages improve selecting commands, buffers, files, etc. from the completing-read and completion-at-point interfaces. These make Emacs insanely ergonomic and excellent.

These replace packages like Helm, Ivy/Counsel/Swiper, and Company. In comparison to these packages, Vertico + Consult + Corfu are lighter-weight, faster, less buggy (in my experience; I’ve tried them all!), and work better with other Emacs packages because they follow the default built-in APIs.

  • Vertico

    Lighter-weight, less buggy vertical completing-read interface. Replaces Ivy. Incredibly flexible. Works out-of-the-box with everything that has a completing-read interface, so you don’t need special *-ivy packages to make it play nice. Recommend adding Marginalia as well by the same author to add extra infos.

  • Consult

    Better than counsel. The live preview is amazing; I use consult-buffer instead of switch-to-buffer, consult-line instead of Swiper. consult-ripgrep is :fire: for searching large projects with instant previewable results. Pairs well with Embark to save results to a buffer.

  • Corfu

    Lightweight pop-up library. Pairs well with Cape by the same author.

See also Orderless which enhances everything from M-x to consult-line to the Corfu popup. Vertico + Consult + Orderless + Marginalia + Corfu + Cape + Embark is sometimes called the “minad stack”.2 It’s the new hotness—that said, it’s gotten really really stable over the past two years.

If you like these packages, consider sponsoring their maintainers! These are some of my favorite open-source projects and I try to support them when I can.

A starter kit built on these #

If you like these packages, you might like my Emacs Bedrock starter kit which, unlike many other starter kits, is meant to be a no-nonsense no-fluff no-abstraction bare-bones start for you to fork and tinker with to your liking. The stock configuration only installs one package (which-key, which is amazing) but includes some extra example configuration. The extras/base.el file includes sample starter configuration for most of the above packages. (I should add eat to it, come to think of it…)

Errata #

  • Eat is not the fastest terminal emulator, Vterm is. Thanks to a Redditor who pointed this out.

  1. The only emulator it’s not faster than is Vterm, which is pretty dang speedy. Eat has been more than fast enough for all my needs however. ↩︎

  2. Embark and Orderless are both developed by Omar Camarena (oantolin) who frequently collaborates with Daniel Mendler. When I asked Omar on Reddit about the name, Omar replied that “minad stack” is fine; another name they’ve tried for the stack is “iceberg”, which I think is a good name too. ↩︎

-1:-- My Top Emacs Packages (Post)--L0--C0--May 30, 2024 12:00 AM

Isma: Film rebooted

After many years dormant, I have decided to restart my photography site. This time, however, it’s not about the business of photography but to simply display some of my work in film. I have always loved photography, I even did it professionally for a while. But there is nothing like the simple act of picking up a film camera, shoot, and pray that something good came out. Hope that the roll actually wound and didn’t get exposed by accident… hey, at least I don’t need to charge anything!

The post Film rebooted first appeared on Arenzana.

-1:-- Film rebooted (Post isma)--L0--C0--May 30, 2024 12:00 AM

Irreal: Casual Avy

I’ve written many, many times about how Avy is one of my favorite packages. Probably 90 per cent of my Emacs navigation is done with Avy. As I’ve said before, you can think of Avy as a generalization Steve Yegge’s recommendation to use search for navigation. Yegge’s idea revolutionized the way I navigate around a buffer and Avy refines that idea and makes it even more useful. As I’ve also said before, if you aren’t using Avy, you’re working too hard.

Now Charles Choi has stepped up to make it even better with Casual Avy. Like his other Casual packages, Casual Avy provides a transient menu to the functions that Avy provides. That’s important because Avy provides too many of them to remember.

Until Casual Avy, most of us solved that problem by restricting our use to one or two of those functions. In my case that’s avy-goto-word-1 and avy-goto-char-timer. Some, like Karthik settle for just avy-goto-char-timer. After reading Karthik’s post I’ve been using avy-goto-char-timer more but I hardly ever use any of the Avy commands except those two.

In a sense, Casual Avy gives you the bet of both worlds. You can still use mainly one or two of the commands but have instant access to all of them at the cost of a single additional keystroke.

I’m really enjoying Choi’s Casual packages. They give you access to all sorts of arcane commands without having to remember a lot of little used keystroke shortcuts. Most of the time, you won’t need them and that’s the point: you don’t have to remember a lot of shortcuts but still have access to the commands you seldom use.

-1:-- Casual Avy (Post jcs)--L0--C0--May 29, 2024 05:02 PM

Amit Patel: Emacs consult-buffer filenames

When working on my web projects I often have same the same filename in different folders, such as projectname/index.html and anotherproject/index.html.

When opening files in Emacs, I might have to open index.html if I'm already in projectname/ or type ../anotherproject/index.html to open from another folder. I switch folders enough that I wanted to have a more consistent way to open things. I now use a global find-file that lets me match on the complete pathname. I can open projectname/index from anywhere, without having to type something different based on which folder I'm in.

When switching buffers, either with the built-in function or with consult-buffer from consult.el, I can type index.html if I only have one index.html file open. If I have more than one open, Emacs will rename them index.html<projectname>, index.html<anotherproject>, etc., and then I would type index projectname. But if I have only one open, then typing index projectname will fail. I wanted to make it more consistent so that I could always type index projectname whether there's only one index.html buffer open or multiple. I implemented this by putting the full filename instead of the buffer name into consult's buffer list:

(defun my/consult--source-buffer ()
  "Make consult-buffer match the entire filename of a buffer"
  ;; items is a list of (name . buffer)
  (let ((items (consult--buffer-query :sort 'visibility
                                      :as #'consult--buffer-pair)))
    ;; TODO: sort these so the current project is first?
     (let* ((label (car it))
            (buffer (cdr it))
            (filename (buffer-file-name buffer)))
       (if filename
             (setq filename (abbreviate-file-name filename))
             (setq label
                   (concat (file-name-directory filename)
                           (propertize (file-name-nondirectory filename) 'face 'consult-file))))
         (setq label (propertize label 'face 'consult-buffer)))
       (cons label buffer))

(defvar my/consult--source-buffer
  `(:name     "Open file"
              :narrow   ?o
              :category buffer
              :history  buffer-name-history
              :state    ,#'consult--buffer-state
              :default  t
              :items    ,#'my/consult--source-buffer)
  "Buffer with filename matching for `consult-buffer'.")

and then I put that in consult-buffer-sources:

(setq consult-buffer-sources
   '(consult--source-hidden-buffer       ;; use SPC to see list
     consult--source-modified-buffer     ;; use * SPC to see list
     my/consult--source-buffer           ;; buffers, with folder names
     consult--source-bookmark            ;; use m SPC to see list
     consult--source-file-register       ;; use r SPC to see list
     consult--source-project-recent-file ;; use f SPC to see list
     consult--source-recent-file         ;; use f SPC to see list

Now consult-buffer shows the filename instead of the buffer name, and I can match on any part of it. I think this has downsides too, as switching buffers takes more keystrokes, but it's also more consistent across different buffer configurations. I've only been using it a few days so far and don't yet know whether I'll keep it.

-1:-- Emacs consult-buffer filenames (Post Amit ( 29, 2024 04:19 PM

Gene Goykhman: I Don’t Trust Parental Controls

I Don’t Trust Parental Controls

May 29, 2024

If you are the parent of a young gamer, consider opting out of any platform parental controls and doing parental controls the old-fashioned way: keeping an eye on what your child is playing and with whom.

This may not be something you’re able to consistently do, and every parent has to make their own careful choices about how to help their child manage their use of technology. I don’t want to diminish the risks or the stakes. For us, our home is small enough and we’re around enough that we tend to always be aware of what’s going on with the TV/computers/tablets/consoles anyway.

When our son was younger we dutifully enrolled him in the various platform-provided family management/parental controls programs offered by Nintendo, Apple, Sony, and Microsoft. As he gets older and we want to reduce or remove those restrictions things are turning into a big mess. The parental controls interfaces are invariably complex, buggy, and inconsistent. Rules vary from platform to platform and this is further complicated by account linking between platforms. I now have multiple support issues open with several platform providers and online game developers because my son stopped having access to in-game voice and text chat in one of his main games. This is after submitting a copy of his passport to prove his date of birth, which I was extremely reluctant to do for privacy reasons.

If I had to do it all again, I would have created those accounts from day 1 with no parental controls, age set to 18 years old, and just tried to stay on top of things so that he made good choices and steered clear of the online risks as best he could.

Is this trading safety for convenience? Maybe, but consider how much safety you’re actually getting here and whether it can be obtained in a different way.

-1:-- I Don’t Trust Parental Controls (Post)--L0--C0--May 29, 2024 04:00 AM

Please note that aggregates blogs, and blog authors might mention or link to nonfree things. To add a feed to this page, please e-mail the RSS or ATOM feed URL to . Thank you!