Erik L. Arneson has an interesting post about using functional programming constructs with Elisp. In particular, he considers pattern matching and tail recursion.

Tail recursion is, in my estimation, one of the most useful properties a programming language can have. Scheme famously has it in its specification and many Lisps have it de facto if not de jure. If you’re not used to using recursion in your programming, that may seem like hyperbole but once you’ve internalized the method, other paradigms seem clumsy. Tail recursion is not really built into Elisp but it’s still possible using the named-let construct. It’s basically the same as Scheme’s named-let so if you’re a Schemer you’ll feel right at home.

Sadly, I haven’t internalized the pattern matching paradigm although I keep promising myself to do so. It’s a powerful idea that extends things like C’s switch statement or Lisp’s cond and case constructs. In Elisp, you use the pcase construct for this. Once you get used to the pattern syntax, it’s a powerful generalization of the common “if-else” constructs most programming languages have.

Arneson’s examples don’t begin to capture the power of these methods. They’re powerful tools that are well worth learning and internalizing. If you’re an Emacser, Elisp provides you an easy way of experimenting with these techniques. Believe me, mastering them will make you a better programmer.

One thing I’ve noticed on my journey to learn OCaml was that reading (text) files wasn’t as straightforward as with many other programming languages. To give you some point of reference - here’s how easy it is to do this in Ruby:

# read entire file to string
content = File.read(filename)

# read lines into an array of lines
lines = File.readlines(filename)

# process lines one at a time (memory efficient when dealing with large files)
File.foreach(filename) { |line| puts line }

In my beloved Clojure the situation is similar:

;; read entire file into string
(slurp filename)

;; process lines one at a time
(use 'clojure.java.io)

(with-open [rdr (reader filename)]
  (doseq [line (line-seq rdr)]
    (println line)))

Basically there are three common operations when dealing with text files:

• reading the whole contents as a single string
• reading the whole contents of a collection of lines (often that’s just a slight variation of the previous operation)
• reading and processing lines one by one (useful when dealing with large files)

When I had to play with files in OCaml for the first time I did some digging around and I noticed that many people were either rolling out their own read_lines function based on the built-in input_line function or using Jane Street’s Base library.

(* Using Base *)
open Core.Std
let contents = In_channel.read_all file
let lines = In_channel.read_lines file

(* homemade read_lines that gathers all lines in a list *)
let read_lines name : string list =
  let ic = open_in name in
  let try_read () =
    try Some (input_line ic) with End_of_file -> None in
  let rec loop acc = match try_read () with
    | Some s -> loop (s :: acc)
    | None -> close_in ic; List.rev acc in
  loop []

lines = read_lines filename

(* homemade read_lines that processes each line *)
let read_lines file process =
  let in_ch = open_in file in
  let rec read_line () =
    let line = try input_line in_ch with End_of_file -> exit 0
    in (* process line in this block, then read the next line *)
       process line;
       read_line ();
in read_line ()

read_lines some_file print_endline

Obviously, this gets the job done, but I was quite surprised such basic operations are not covered in the standard library. Turns out, however, that the situation has changed recently with OCaml 4.14 with the introduction of the module In_channel:¹

(* read the entire file *)
let read_file file =
  In_channel.with_open_bin file In_channel.input_all

(* read lines *)
let read_lines file =
  let contents = In_channel.with_open_bin file In_channel.input_all in
  String.split_on_char '\n' contents

List.iter print_endline (read_lines filename)

While you still need to roll out your own read_file and read_lines functions, the implementation is significantly simpler than before. Even more importantly, the code is now more reliable as noted by Daniel Bünzli:²

Be careful, input_line is a footgun and has led to more than one bug out there – along with open_in and open_out defaulting to text mode and thus lying by default about your data.

input_line will never report an empty final line and performs newline translations if your channel is in text mode. This means you can’t expect to recover the exact file contents you just read by doing String.concat "\n" on the lines you input with input_line.

Also of course it doesn’t help with making sure you correctly close your channels and don’t leak them in case of exception. The new functions finally make that a no brainer.

You can also use In_channel.input_line to read file contents line by line and avoid excessive memory allocation. I’m still missing something like Clojure’s line-seq that create a lazy seq from which you can obtain the file lines, but I guess this should be doable in OCaml one way or another.³

I encourage everyone to peruse the documentation of In_channel to learn more about the functions it offers and the advantages of using it over the legacy input_line function.

I really wish that someone would update OCaml’s page on file manipulation to include coverage of the OCaml 4.14 functionality (perhaps I’ll do this myself). I’m guessing this outdated page and other legacy docs are sending a lot of people in the wrong direction, which was the main reason I’ve decided to write this article.

That’s all I have for you today. Keep hacking!

As you know, Emacs can display most of the common image formats such as SVG, JPEG, PNG, and GIF but what about formats, such as webp, that aren’t handled natively by Emacs? Álvaro Ramírez has another quickie that tells us how to do it.

It turns out to be simple, especially if you already have ImageMagick or one of a couple of other external image converters already on your system, it’s just a matter of telling Emacs to use the external image converter. Here’s the magic spell:

(setq image-use-external-converter t)

If you don’t already have ImageMagick installed, you might find it a worthwhile addition to your system. Previously, Ramírez considered the problem of combining a series of JPEGs into a single PDF and told us how to do that. His solution was in the context of his dwim-shell-command framework but it’s just a simple call to ImageMagick’s convert command. Many of his simple DWIM Emacs shell functions make use of ImageMagick so you might also want to consider adding dwim-shell-command to your Emacs configuration.

Ramírez has been blogging up a storm lately. Many of his posts offer actionable suggestions for solving the small but annoying problems that we all run into. If you haven’t already, you may want to add his feed to your RSS reader.

Links in org-mode by default are displayed as “descriptive” links, meaning they hide their target URLs (or a destination in general). While this looks great, it makes it a bit tricky to figure out how you can edit their URL. There are two easy options:

1. Just press C-c C-l (org-insert-link) while your point is within a link and you’ll be prompted to edit its URL in the minibuffer. You can use the same command to create new links (when your point is not on an existing link).

2. You can convert the “descriptive” links to “literal” links¹ by invoking the command M-x org-toggle-link-display. You can also toggle between the two display modes for links via the mode’s menu (under “Hyperlinks”).

And that’s all I have for you today. Admitted, I keep forgetting about this all the time, as I rarely use org-mode, which is the reason I’ve decided to write this short article. Keep hacking!

The altcaps package helps you apply alternating letter casing to convey sarcasm or mockery. For example, convert this:

I respect the authorities

To this:

i ReSpEcT tHe AuThOrItIeS

The altcaps package thus makes you more effective at textual communication. Plus, you appear sophisticated. tRuSt Me.

Use any of the following commands to achieve the desired results:

• altcaps-word :: Convert word to alternating letter casing. With optional NUM as a numeric prefix argument, operate on NUM words forward, defaulting to 1. If NUM is negative, do so backward. When NUM is a negative prefix without a number, it is interpreted -1.

• altcaps-region :: Convert region words between BEG and END to alternating case. BEG and END are buffer positions. When called interactively, these are automatically determined as active region’s boundaries, else the space between mark and point.

• altcaps-dwim :: Convert to alternating letter casing Do-What-I-Mean style. With an active region, call altcaps-region. Else invoke altcaps-word with optional NUM, per that command’s functionality (read its documentation).

• Package name (GNU ELPA): altcaps
• Official manual: https://protesilaos.com/emacs/altcaps
• Git repo on SourceHut: https://git.sr.ht/~protesilaos/altcaps
  • Mirrors:
    • GitHub: https://github.com/protesilaos/altcaps
    • GitLab: https://gitlab.com/protesilaos/altcaps
• Mailing list: https://lists.sr.ht/~protesilaos/altcaps
• Backronyms: Alternating Letters Transform Casual Asides to Playful Statements. ALTCAPS Lets Trolls Convert Aphorisms to Proper Shitposts.

You guys always jump on me and accuse me of being cantankerous when I go off on a rant like this but, really, it’s too much to bear. I’ve noticed lately that some people are referring to Emacs as “eMacs” as if Emacs stood for “electronic macs”, or “electronic macros”, or something. It doesn’t. Emacs is widely understood to stand for “Editing MACroS”, although Irreal’s go to guy for Emacs history, Lars Brinkhoff, says he can find no evidence for that. Regardless, the E certainly does not stand for “electronic” so if you’re going to write about Emacs, can you please name it correctly and not make it look like a marketing term?

Yes, yes. I know it’s a small thing and hardly worth commenting on but names do matter and it’s important to get them right. Otherwise, as with the word “hacker”, the ignorant will kidnap the term and change its meaning. Don’t let that happen to our beloved editor. Fight this abomination whenever and wherever it raises its ugly head.

Added before publication: Perhaps this explains it.

Torstein K. Johansen has an interesting post on configuring a Mac to be comfortable for a Linux user. Johansen is a self described “die hard Linux user” but recently had to work on a Mac. Macs are Unix machines but they’re based on FreeBSD and are certainly not Linux so if you’re a Linux user it’s useful to know how to configure a Mac to be as much like a Linux workstation as possible.

The most important thing, of course, is getting a decent Emacs installed. It used to be that Apple included Emacs in their distributions but it was a very old version and not one that any modern day user would want to use. They’ve since stopped including it so you’ve no choice but to install your own. I do that by compiling from source but Johansen chose to load his from Homebrew.

Once Emacs is installed, most of the rest of Johansen’s configuration involves replacing the default, older, BSD Unix utilities with their more up to date GNU versions. His post shows how to do all that.

We here at Irreal are, as most of you know, a Mac shop so we don’t have that problem but Johansen’s post is still worthwhile. For example, I learned about btop, a top replacement and used his recipe to install it. I’m content with the BSD versions of the Unix utilities but if you prefer the GNU versions, he shows you how to install them.

All in all, its a really useful post for anyone who wants to make their Mac the best possible workstation. Macs are famously Unix based but the default install hides a lot of that from you. Johansen shows you how to fix that.

Everybody hates slide decks. Jeff Bezos even famously banned them from Amazon. Still, most of us who are called upon to give a presentation will make slides the center of that presentation. There are, of course, dedicated programs like PowerPoint, Keynote, and the various clones that come with packages like LibreOffice but few Emacs users are going to want to wade into that swamp.

Happily there are several Emacs packages that let you prepare slides from the comfort of your editor. David Wilson over at System Crafters has an informative video that explores one of those packages: org-tree-slide.

Based on Wilson’s video, I’d judge that the application doesn’t produce slides as nice looking as some of the other packages but it does have the advantage of not needing any other packages. You just load the org-tree-slide package and you’re good to go. The input is very simple: you just make an Org file and the headers become the slides. On the plus side, you can have images and code blocks and these get exported to the slides. Wilson shows how to control things like the font and image sizes and simple animation effects.

The video is 31 minutes, 38 seconds long so you’ll need to schedule some time. If you’re looking for a simple package to generate simple slides, this package is certainly worth taking a look at.

Just a quickie from Álvaro Ramírez. If you’re a Mu4e user and would like to have an email’s status shown as one or more icons instead of a series of comparatively opaque letters but don’t want to deal with all-the-icons, Ramírez has the answer for you.

It’s pretty simple. You choose the icons you want for each status indication—or simply copy Ramírez’s—and add a series of configuration items to your init.el. Those items are listed in Ramírez’s post so take a look if your interested in adding your own.

It's been a weird few weeks for decentralized social media. The collapse of Twitter at the hands of an incompetent billionaire has led to a massive wave of users on the Fediverse¹, from under a million to over seven million now. And at the time of this writing Twitter hasn't even finished collapsing yet; the site is still hobbling along, albeit with gaping holes. Though by the time I've finished writing this post, who knows. A lot can happen.

As you might expect, the huge influx has caused some technical problems to the Fediverse. The mega-instances like mastodon.social saw slow page load times and hours of lag between something posted and it propagating out to other servers. More reasonably-sized servers have still seen some lesser propagation lag, but the main effect of this influx has been nontechnical. New users have had a hard time finding well-run servers that are accepting new members, and there has been a lot of complaining that the system is hard to understand or navigate due to its distributed nature.

whenever twitter makes a bunch of its users angry we get a new wave of activity on the [Fediverse] and all the new mastodon users engage in the primary hobby of a new mastodon user, which is listing all of the reasons why mastodon doesn't work. it's real fun

- @rootsworks@mastodon.social

Some of this is simply a necessary difference between a single unified corporate system to a distributed network. In the 1990s we saw a similar type of confusion as people left silos like America OnLine (AOL) and CompuServ to explore the early days of the World Wide Web. It wasn't as polished, and there was no central view of the entire network. You had to do more exploring to find independent communities that ran their own sites. People who remember making this shift know now that the effort was worth it, but back then you couldn't fault people for wondering why things couldn't just be easy like it used to be.

But I believe there's more to the situation with the Fediverse today than simply the differences that arise out of technical necessity.

I recently finished reading the book Seeing Like a State by James Scott. There's a lot to unpack in this book², but I want to talk about the way it defines the term legibility. Legibility describes the degree to which a place is understandable and navigable to an outsider.

My favorite example of legibility is street addresses. When I lived in Thailand I was initially very surprised to learn that even long-time residents had a very rough grasp of the names of most of the streets in the city. People navigated by landmarks instead. As a newcomer to the city it was very disorienting; I had to set aside my ideas I brought in about how to navigate and learn to read the city like a local. In the end after living there two years I knew the names of four or five of the major streets, but when someone wanted to know where my house was, I didn't give them a street address; I told them it was a block east of the bus terminal.

This attitude towards navigating looks different depending on whether you're an outsider or a resident. To a resident it's no big deal, but to someone who's new to the city it can be frustrating and bewildering. In some cases (for instance, cities that rely on tourism) there are incentives for the locals to increase legibility, but other factors can incentivize people to reduce their legibility.

Legibility is particularly interesting when it lies at the crux of a power imbalance, and the book describes many such situations. As pre-modern states in Europe consolidated their power, they looked for ways to collect taxes and conscript soldiers more effectively. Customary naming made this very difficult.

Only wealthy aristocrats tended to have fixed surnames…Imagine the dilemma of a tithe or capitation-tax collector [in England] faced with a male population, 90% of whom bore just six Christian names (John, William, Thomas, Robert, Richard, and Henry).

Seeing Like a State by James Scott

In order to consolidate their power over their citizens, states rolled out policies to increase the legibility of the population they ruled over; they started to require that everyone take a surname in order to uniquely identify them to the state in censuses and tax documents. As you can imagine, this didn't go over well; the historical record documents intense resistance, in some cases even open rebellion. The people themselves had no need for surnames; they got along fine with a given name supplemented when necessary with contextual specifiers. "John" might be "John the Baker" in some contexts and "Short John" in others and "John Underhill" to people in the next town. This system worked fine for everyone involved, except those wishing to exert their authority from the outside.³

If this sounds familiar to you, it might be because you were paying attention to social media controversies of the last decade! Prominent advertising companies like Facebook and Google attempted to roll out tremendously unpopular policies requiring users to identify themselves using their legally-documented name⁴. Though these policies were always accompanied by some flimsy justification about "user safety", the real goal was to make their users more legible, primarily for advertising purposes, but also to law enforcement and other authorities.

Well, it turns out just like villagers in premodern France, lots of users don't want to make themselves more legible! Even setting aside the impossibility of a company like Facebook accurately identifying the difference between a pseudonym and a legal name, there are a lot of great reasons to not want to be easy to find. Avoiding targeted advertising is just the tip of the iceberg; ask any member of a marginalized group and they'll tell you that being easy to find can have a high cost when it exposes you to targeted abuse.

Twitter features full-text search of everything posted. This is fantastic for legibility; if you're curious about a topic, you can always see who's talking about it. One of the ways this gets used on Twitter is to pick fights. Trolls find a hot topic and barge uninvited into conversations to yell at people who disagree with their position. On the Fediverse, search is opt-in instead of opt-out. Normal text doesn't get indexed, but hashtags do. If you want your post to become searchable under certain terms, a # is all it takes, but the randos won't show up unless you go out of your way to invite them.

In some ways, people today coming to the Fediverse from corporate social media remind me of how I felt when I first moved to Thailand—lost and bewildered by the lack of street signs. They've spent a lot of time on the highways of platforms that prioritize "engagement" at all cost, and it's taking a while for it to sink in that not all the Internet works that way. They've never considered that illegibility can be a defense mechanism..

Become illegible.⁵

[1] The Fediverse is a network of interconnected social media servers that exchange posts. Most of its usage is based on a similar model to Twitter, but there are some systems on it that focus on photos or videos. Because the most common Fediverse server is called Mastodon, many people use the word Mastodon to talk about the network, similar to how in the 1990s people said "Internet Explorer" when they meant the web.

[2] While the book is insightful, it is pretty long, and the two case studies in the middle drag on a bit. I strongly recommend reading the first three chapters and the last two chapters, but you can still get 90% of the insight by skipping the two very detailed case studies in the middle.

[3] The scary thing about this is how absolute the normalization of surnames became over time despite the intense resistance. In the end, people accepted the greater control, and even tho surnames were rare in many societies only a few hundred years ago, nowadays they are thought of by most people as "natural".

[4] These policies often misleadingly referred to the legal name as the "real name", as if legal process had some magical access to reality itself which could not be achieved using the customary naming patterns people have been using for millennia.

[5] I have to admit to stretching this a bit for a punchy closing line, but of course it's not as simple as "legibility bad"; obviously there are many cases in which you want legibility. I'm trying to convey the fact that legibility does have downsides, and if you've never even considered this, then it's impossible for you to have a productive conversation about social software in today's context.

Syntopikon has an interesting interview with Mickey Petersen, the proprietor of Mastering Emacs and all around Emacs expert and expositor. He’s no stranger to Irreal readers so it’s always nice to see him discuss matters. The last time I remember seeing an interview with him was in 2014 in an on-line chat with Sacha Chua.

Like many of us, Mickey abandoned his first attempt to use Emacs. That was in his pre-college days when he was just discovering and learning Linux. Later, when he got to the university, he adopted Emacs party in reaction to the noisy voices insisting that all real hackers used Vim. When you read Mickey now, it’s easy to believe that he’s always had a thorough knowledge of Emacs and didn’t struggle like the rest of us. Of course, that’s wrong. He used it for some time before, as he says, the light came on and he realized the true potential of Emacs.

He also has an interesting exchange with the interviewer on the use of Emacs for non-technical or technical-adjacent users. The interviewer is an Emacs user too but he uses it for writing. I’ve long felt that all writers should at least try Emacs. After all, it’s all about wrangling text whether you’re a developer or a writer and Emacs excels at that. If you learn enough Elisp to make minor customization’s you can mold Emacs into a your ideal writing environment. Mickey believes that more could be done to make learning Emacs easier for the non-developer and he explores a few of those in the interview.

Like most things that Mickey’s involved with, the interview is interesting and worth reading. A few minutes of your time would be well spent.

• Upcoming events:
  • Emacs APAC (virtual, in English) https://emacs-apac.gitlab.io/ Sat Nov 26 0030 Vancouver / 0230 Chicago / 0330 Toronto / 0830 GMT / 0930 Berlin / 1400 Kolkata / 1630 Singapore
  • Emacs Berlin (virtual, in English) https://emacs-berlin.org/ Wed Nov 30 0930 Vancouver / 1130 Chicago / 1230 Toronto / 1730 GMT / 1830 Berlin / 2300 Kolkata – Thu Dec 1 0130 Singapore
  • Emacs users group Slovenia https://emacs.si/ Thu Dec 1 1100 Vancouver / 1300 Chicago / 1400 Toronto / 1900 GMT / 2000 Berlin – Fri Dec 2 0030 Kolkata / 0300 Singapore
  • EmacsConf 2022 - Day 1 https://emacsconf.org/2022/ Sat Dec 3 0600 Vancouver / 0800 Chicago / 0900 Toronto / 1400 GMT / 1500 Berlin / 1930 Kolkata / 2200 Singapore
  • EmacsConf 2022 - Day 2 https://emacsconf.org/2022/ Sun Dec 4 0600 Vancouver / 0800 Chicago / 0900 Toronto / 1400 GMT / 1500 Berlin / 1930 Kolkata / 2200 Singapore
• Emacs configuration:
  • Εισαγωγή στο Linux - Lecture06-01 - install Emacs Packages with MELPA (08:51)
  • Converting a Literate Org Config to Guix Home - System Crafters Live! (01:50:50)
  • jacmoe's Doom-Emacs configuration: A Hotel California of creative writing.
  • GitHub - Likhon-baRoy/.emacs.d: [ Dream Emacs 🫶 ] My GNU Emacs configuration. (Reddit)
• Emacs Lisp:
  • Why Are Lisp Macros So Great!? (Reddit)
  • ptree.el - managing property trees
• Appearance:
  • Learn how to override fontification (14:13)
  • Learn how to fontify the strings foo and bar in a sh-mode buffer using font-lock-add-keywords (18:05)
• Writing:
  • Auto-correct the "*ign" -> "*ing" typo
  • Linter de #markdown para #emacs (03:20:19)
• Org Mode:
  • [MAINTENANCE] Org orphanage?
  • Small package to mark org-agenda conflicts (Reddit)
  • Org Mode Insert Table Reference - Noonker — thoughts, guides, etc
  • Org-Mode Inline Macro in the Buffer
  • Emacs | "External brain, and all that." | Introducing My "Captain's Log" (08:37)
  • Jeremy Friesen: Project Dispatch Menu with Org Mode Metadata, Denote, and Transient
  • Org Roam:
    • org-project-manager: A plugin to manage projects with org-roam (Reddit)
    • An example workflow with Org-roam
  • Import, export, and integration:
    • notxor-blog: Mis modificaciones al paquete de org-static-blog para generar un blog estático con org-mode desde Emacs. - notxor-blog - Codeberg.org
    • GitHub - grtcdr/forgecast: Cast documents to their forges
    • Just released Org2Blog v1.1.16
    • Jean-Christophe Helary: An even newer version of my Capture app
  • Org development:
    • ox-html: Update from MathJax 2 to MathJax 3+
    • org-attach.el: ID to path functions may return nil
• Completion:
  • eglot-tempel: bridge for tempel templates with eglot
  • corfu-doc merged into corfu main
• Coding:
  • Demo of String inflection Emacs package to cycle through string case styles: camel, snake, kebab
  • Virtual Environments with Eglot, Tramp, and Pyright · robbmann (Reddit)
  • sweep: SWI-Prolog Embedded in Emacs
  • Using Emacs With PostgreSQL (2021)
  • Catch your JS console.log you forgot to remove with Emacs and Magit (Reddit)
  • Marcin Borkowski: Streamlining my workflow with Magit and BitBucket (Reddit)
  • Emacs: Getting started with eglot (using golang) (05:10)
• Shells:
  • Clear screen without deleting previous command lines and outputs | term-mode
  • A Better Cat for Eshell | The Best Site Ever! (not)
• Web:
  • eww is awesome. What do you use it for?
• Chat:
  • Mastodon alternative timeline layout (Reddit)
  • Sacha Chua: Solving the mastodon.el error mastodon-auth–access-token: invalid
• Mail and news:
  • Letting mu4e reply from a catchall address (Irreal, lobste.rs)
  • mu4e-query: S-expression query builder for mu4e (Reddit)
  • tvaughan's Emacs config for mu4e
  • notmuch-hello-unread: Notmuch functions to show unread count in hello buffer
  • Sacha Chua: Logging sent messages to Org Mode with message-sent-hook
• Doom Emacs:
  • DOOM Emacs intro - Cheap DIY Solutions for the Modern Maker (Reddit)
• Fun:
  • rcd-box.el - makes box drawings
• Community:
  • Weekly Tips, Tricks, &c. Thread
  • For whose use Emacs and VS Code, when and why you use VSCode? #emacs #vscode
  • 200ok: reClojure 2022, now with a physical venue in Lucerne!
  • Lex Fridman - after years of Emacs switched to VScode (Reddit)
  • An Interview with Mickey Petersen, author of Mastering Emacs (Reddit, HN)
  • Retiring part 3 - What's Next - C'est la Z (Irreal) - Mike Zamansky
  • TAONAW - Emacs: Writing Modes - wiki vs blogs
• Other:
  • cerberus/emacs-29-new-functions.org at master · NapoleonWils0n/cerberus · GitHub (YouTube, 24:07)
  • 15 reasons why I use emacs
  • Semi-Automate Boring Tasks: Replacing Twitter-Snippets
  • Calendar.el in Croatian language (Reddit)
  • Marcin Borkowski: Doubling backslashes (Irreal)
  • Emacs Long Lines, This Time With Feeling (08:50)
  • Take Charge of PDF in GNU Emacs (display popup annotation, Reddit)
  • Getting (Doom) Emacs to work with Unity on macOS (with Macports)
  • Emacs on an iPad
  • How to Install and Setup Emacs on a Chromebook (11:24)
  • I didn't know that there exists an Emacs clone written in Scheme. It is called "Edwin" and part of MIT/GNU Scheme. (Reddit)
  • Modern Editor Architecture (Reddit)
• Emacs development:
  • emacs-devel:
    • Clarification on why completion is limited to the text in the candidates
    • some projects starting to use shorthands
    • People can now register notifiers to find out when tree-sitter reparses
    • why macros are preferred over inline functions
    • a thread on improving Rmail, with thoughts on terminology (filtering vs summarization)
    • a thread on improving bookmarks
  • Rename 'elisp-eval-buffer' to 'elisp-eval-region-or-buffer' (bug#59350)
  • EUDC: Revert eudc-server-hotlist default change
  • Improve 'defvar-keymap' docstring
  • New Rmail summary "by thread"
  • * lisp/keymap.el (defvar-keymap): Add support for repeat-mode.
  • Accommodate ircs:// URLs in url-irc and browse-url
  • Make auth-source-pass behave more like other backends
  • New command 'project-list-buffers' bound to 'C-x p C-b' (bug#59153)
• New packages:
  • soong-mode: Support for the Soong build system (MELPA)
  • gpt: Run instruction-following language models (MELPA)
  • consult-hatena-bookmark: Consult commands for the Hatena Bookmark (MELPA)
  • consult-git-log-grep: Consult integration for git log grep (MELPA)

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

Sebastian Schulze has an interesting post on handling email To and From addresses. His procedure when supplying an Email address to, say, a Website such as some-site.com is to specify some-site.com@his-domain.com where his-domain.com is his domain. That allows him to apply appropriate filters and discover the source of spam.

In order for this to work, he needs two things:

1. His email provider must pass all email to him regardless of the user name.
2. He has to set the From address on any replies to some-site.com@his-domain.com.

The first item is generally doable if you have control of your domain, especially if you run your own email server. The second is a lot harder with almost every email client. Fortunately Schulze uses mu4e so it’s relatively easy with a bit of Elisp.

Actually, mu4e can almost handle this out-of-the-box. You can specify your email addresses and mu4e will respond with the appropriate From address. Schulze’s situation is a little more complicated. You could do it with vanilla mu4e but you’d have to constantly housekeep your mu4e configuration. Schulze’s solution takes care of everything automatically.

The Elisp required is minimal so it’s an easy solution providing you have your own domain and are using mu4e. My own—not as good—solution is to add specific “possibly spam” addresses to my mail server and use that for sites that are possible sources of spam. Schulze’s solution is clearly superior and worth emulating if you can.

Creating a Means of Quickly Navigating Amongst a Projects Important “Pages”

At Software Services by Scientist.com I work on several different projects. Ideally, one project at a time, but within a week I might move between two or three. Note taking procedures help me re-orient to a new project.

On Wednesday I spent some time reflecting on the common jumping off points for a project:

Local Source Code

the local repository of code for the project; thus far each project has one repository.

Remote Source Code

the remote repository where I interact with issues and pull requests.

Remote Project Board

the page that has the current project tasks and their swimlanes.

Agenda/Timesheet

the place where I track my local time and write notes.

Local Project Note

the place where I track important links or information regarding the project.

When I’m working on the project, I’m often navigating between those five points. Since I work in Emacs I figured I’d write up some code.

First, I thought about the data. Where should I store this information? Looking at the above list, the best candidate was the Local Project Note; a note written in Org-Mode and I use Denote to help me manage this kind of note.

For each project document I added the following keywords (e.g. those that can be found by the org-collect-keywords function):

#+PROJECT_NAME:

By convention, this is the short-name that I use for my timesheet and task management. (See Org Mode Capture Templates and Time Tracking for more details.)

#+PROJECT_PATH_TO_CODE:

The file path to the code on my machine.

#+PROJECT_PATH_TO_REMOTE:

The URL of the remote repository.

#+PROJECT_PATH_TO_BOARD:

The URL of the remote project board.

The Helper Functions

I wanted a common mechanism for selecting the project. I wrote the following function:

(cl-defun jf/project/list-projects (&key (project ".+")
					 (directory org-directory))
  "Return a list of `cons' that match the given PROJECT.

The `car' of the `cons' is the project (e.g. \"Take on Rules\").
The `cdr' is the fully qualified path to that projects notes file.

The DIRECTORY defaults to `org-directory' but you can specify otherwise."
  (mapcar (lambda (line)
	    (let* ((slugs (s-split ":" line))
'		   (proj (s-trim (car (cdr slugs))))
		   (filename (file-truename (s-trim (car slugs)))))
	      (cons proj filename)))
	  (split-string-and-unquote
	   (shell-command-to-string
	    (concat
	     "rg \"^#\\+PROJECT_NAME: +(" project ") *$\" " directory
	     " --only-matching --no-ignore-vcs --with-filename -r '$1' "
	     "| tr '\n' '@'"))
	   "@")))

It searches through my org-directory for the given project; by default that project is a fragment of a regular expression. That regular expression is “any and all characters.” I can use the above function as a parameter for completing-read.

I also want to set my default project. For this, I used Transient’s transient-define-suffix function. Below is jf/project/transient-current-project, a function I use to manage and display the jf/project/current-project variable.

(defvar jf/project/current-project
  nil
  "The current contextual project.")

(transient-define-suffix jf/project/transient-current-project (project)
  "Select FILES to use as source for work desk."
  :description '(lambda ()
		  (concat
		   "Current Project:"
		   (propertize
		    (format "%s" jf/project/current-project)
		    'face 'transient-argument)))
  (interactive (list (completing-read "Project: "
				      (jf/project/lis't-projects))))
  (setq jf/project/current-project project))

I also recognized that I might want to auto-magically select a project. So I wrote up the basic jf/project/find-dwim:

(defun jf/project/find-dwim ()
  "Find the current project."
  (completing-read "Project: " (jf/project/list-projects)))

The above function could look at the current clock in Org Mode and determine the associated project. Or, if I’m in a repository look to see what project it is associated with. Or whatever other mechanisms. For now, it prompts for me to pick a project.

The Interactive Functions

With the above “plumbing” I wrote five functions:

• jf/project/jump-to-agenda
• jf/project/jump-to-board
• jf/project/jump-to-code
• jf/project/jump-to-notes
• jf/project/jump-to-remote

The jf/project/jump-to-agenda function is a bit different, it tries to jump to today’s agenda item for the project.

(cl-defun jf/project/jump-to-agenda (&optional project
				     &key
				     (tag "project")
				     (within_headline
				      (format-time-string "%Y-%m-%d %A")))
  "Jump to the agenda for the given PROJECT."
  (interactive)
  (let ((the-project (or project (jf/project/find-dwim))))
    (with-current-buffer (find-file jf/pri
mary-agenda-filename-for-machine)
      (let ((start (org-element-map (org-element-parse-buffer)
		       'headline
		     ;; Finds the begin position of:
		     ;; - a level 4 headline
		     ;; - that is tagged as a :project:
		     ;; - is titled as the given project
		     ;; - and is within the given headline
		     (lambda (hl)
		       (and (=(org-element-property :level hl) 4)
			    ;; I can't use the :title attribute as it
			    ;; is a more complicated structure; this
			    ;; gets me the raw string.
			    (string= the-project
				     (plist-get (cadr hl) :raw-value))
			    (member tag
				    (org-element-property :tags hl))
			    ;; The element must have an ancestor with
			    ;; a headline of today
			    (string= within_headline
				     (plist-get
				      ;; I want the raw title, no
				      ;; styling nor tags
				      (cadr
				       (car
					(org-element-lineage hl)))
				      :raw-value))
			    (org-element-property :begin hl)))
		     nil t)))
	(goto-char start)
	(pulsar-pulse-line)))))

The jf/project/jump-to-board function assumes a remote URL.

(cl-defun jf/project/jump-to-board (&optional
				    project
				    &key
				    (keyword "PROJECT_PATH_TO_BOARD"))
  "Jump to the given PROJECT's project board."
  (interactive)
  (let* ((the-project (or project (jf/project/find-dwim)))
	 (filename (cdar (jf/project/list-projects :project the-project))))
    (with-current-buffer (find-file-noselect filename)

      (let ((url (cadar (org-collect-keywords (list keyword)))))
	(eww-browse-with-external-browser url)))))

The jf/project/jump-to-board function assumes a directory on my local machine. The code is similar to the jf/project/jump-to-board.

(cl-defun jf/project/jump-to-code (&optional
				   project
				   &key
				   (keyword "PROJECT_PATH_TO_CODE"))
    "Jump to the given PROJECT's source code."
    (interactive)
    (let* ((the-project (or project (jf/project/find-dwim)))
           (filename (cdar (jf/project/list-projects :project the-project))))
      (with-current-buffer (find-file-noselect filename)
        (let ((filename (file-truename (cadar
					(org-collect-keywords
					 (list keyword))))))
          (if (f-dir-p filename)
              (dired filename)
            (find-file filename))))))

The jf/project/jump-to-notes prompts for the project and then finds the filename.

(cl-defun jf/project/jump-to-notes (&optional project)
  "Jump to the given PROJECT's notes file.

Determine the PROJECT by querying `jf/project/list-projects'."
  (interactive)
  (let* ((the-project (or project (jf/project/find-dwim)))
	 (filename (cdar (jf/project/list-projects :project the-project))))
    (find-file filename)))

Akin to the jf/project/jump-to-board, the jf/project/jump-to-remote opens a remote URL.

(cl-defun jf/project/jump-to-remote (&optional
				     project
				     &key
				     (keyword "PROJECT_PATH_TO_REMOTE"))
  "Jump to the given PROJECT's remote."
  (interactive)
  (let* ((the-project (or project (jf/project/find-dwim)))
	 (filename (cdar (jf/project/list-projects :project the-project))))
    (with-current-buffer (find-file-noselect filename)
      (let ((url (cadar (org-collect-keywords (list keyword)))))
	(eww-browse-with-external-browser url)))))

The Menu

Using Transient I define a menu for my projects. Lower case is for dispatching to the current project. Upper case prompts for the project then dispatches.

(transient-define-prefix jf/project/menu ()
  "My Project menu."
  ["Projects"
   ["Current project"
    ("a" "Agenda…" (lambda () (interactive)
		     (jf/project/jump-to-agenda jf/project/current-project)))
    ("b" "Board…" (lambda () (interactive)
		    (jf/project/jump-to-board jf/project/current-project)))
    ("c" "Code…" (lambda () (interactive)
		   (jf/project/jump-to-code jf/project/current-project)))
    ("n" "Notes…" (lambda () (interactive)
		    (jf/project/jump-to-notes jf/project/current-project)))
    ("r" "Remote…" (lambda () (interactive)
		     (jf/project/jump-to-remote jf/project/current-project)))
    ("." jf/project/transient-current-project :transient t)]
 '  ["Other projects"
    ("A" "Agenda…" jf/project/jump-to-agenda)
    ("B" "Board…" jf/project/jump-to-board)
    ("C" "Code…" jf/project/jump-to-code)
    ("N" "Notes…" jf/project/jump-to-notes)
    ("R" "Notes…" jf/project/jump-to-remote)]
   ])

Conclusion

During my day I spend a lot of time writing and reading; and for large chunks of time those are all related to a single project. Each project has predictable “places” where I will read and write.

The above functions help me both document the relationship of those predictable “places” and automate my navigation to those different tools. In all things Emacs remains my homebase; it is where I can go to re-orient.

My jf-project.el document has the above code and any further updates, bug fixes, etc to the above now static code.

If you get mastodon-auth--handle-token-response: Mastodon-auth--access-token: invalid_grant: The provided authorization grant is invalid, expired, revoked, does not match the redirection URI used in the authorization request, or was issued to another client. while trying to set up mastodon.el from MELPA, you might have an outdated version. Try the following steps:

• M-x package-delete mastodon
• Restart Emacs
• M-x package-refresh-contents
• M-x package-install mastodon

If that doesn't work, try installing it from the Git repository: https://codeberg.org/martianh/mastodon.el.git

Posting this here to make it searchable.

Finally! A new take on the quitting Vim meme:

I believe AGI will develop the ability to prevent humans from terminating it. After all vim got 60% there with a fraction of compute resources.

— Ferenc Huszár (@fhuszar) November 15, 2022

That’s actually pretty funny. Of course, as someone pointed out it could just as well apply to Emacs. Since this isn’t Friday, I won’t toss in red meat by noting that the real problem is that Emacs and Vim don’t have a menu item with a Quit entry¹ for the cognitively challenged.

After working on my wiki for a couple of weeks straight, I’m starting to calm down a bit. I’m thinking of what I write, and where.

Since the wiki is organized by categories, it’s easy to start topics without committing to a whole body of text. Say I want to write about a video game I just finished. I could create a “Video Games” topic and under it, another article: “Doom.” “Video Games” remain blank, a placeholder until a point in the future when I have more to expand on.

While this is doable on most blogs (this one included), the idea of going back to a post feels a bit out of place, since the blogs are chronological.

On the other hand, writing in the blog is more personal. It’s org-mode, which I also use to write my journal. Emacs just feels personal. It’s a superior writing environment that lets me spill my thought on the screen without getting distracted. Writing in a blog just feels more like a narrative unfolding, more of the why and not just the how. It’s not a coincidence this blog is called what it’s called; I always reserved a sense of irony in what I write.

Writing has become a part of my identity. I spend hours in front of Emacs each day writing what I do and organizing my day. By extension, having a blog lets me extend this identity further: I am more me because I blog.

Just thought I’d share.

reClojure is a free, community driven conference that brings together inspiring speakers in a warm and friendly atmosphere. This year, it's a two-day (Dec 2 and 3) conference.

We are also happy to announce that this year we will have a physical venue in Switzerland where we can gather as a community, watch talks, hack all things Clojure, and have a good time together.

Our hosts will be Ardeo (ardeo.ch) - the venue is their Coworking Hub in Lucerne. The space is just a couple minutes from Lucerne central station and features three rooms - one per track and a hacking/chillout space. Attending the conference is free (as in beer). Optional donations are welcome. For Ardeo, the Coworking Hub is central to the sharing economy and practising openness and transparency. As a driver for innovation, Ardeo is a long-standing partner of 200ok. Phil and Alain from 200ok are co-hosting.

The first day, Dec 2nd, will be hosted in its entirety from 10:30 until 21:30. The second day is in conflict with the EmacsConf 2022, which is also being hosted in the space on the Dec 3rd, so the official duration for the reClojure event will be scheduled as 10:30 - 14:30. After that the focus will be on the EmacsConf. Optionally, should there be demand and space we might run the rest of the reClojure talks in a separate room.

You can find details about the reClojure schedule on their website https://www.reclojure.org/

Ardeos' Coworking Hub spots for reClojure 2022 are limited to 25. Hence, sign up early, and release your seat just as early if you cannot attend. For signing up, please use this Meetup event:

• Dec 2: https://www.meetup.com/zh-clj-zurich-clojure-user-group/events/289808329/
• Dec 3: https://www.meetup.com/zh-clj-zurich-clojure-user-group/events/289808407/

Please make sure to sign up directly at the Meetup event of the organizers, as well, so that they have a proper grasp of how many people attend the online conference: https://www.meetup.com/london-clojurians/events/289598000/

We are very much looking forward to reClojure 2022 - to meeting great people, having interesting discussions and sharing all things Clojure and Lisp \(^_^)/

If you'd like to attend reClojure and EmacsConf, please sign up for both events separately. Here's more information about EmacsConf.

Some impressions from Ardeos Coworking Hub in Lucerne

Mike Zamansky, who is well known to Irreal readers for his excellent, some say definitive, Using Emacs Series just announced that he is planning on retiring at the end of the Spring semester. In a series of three posts Zamansky lays out why he is retiring, what he feels he’s accomplished, and what his future might hold.

Irreal has focused almost exclusively on his Using Emacs Videos but I read all his posts and several of them are interesting even if not Irreal fodder. If you’re interested in CS education and how best to train new engineers, you should definitely be reading his blog. It’s low traffic so it’s easy to keep up with.

From a purely selfish point of view I hope he devotes all his newly found free time to making new Emacs videos but realistically we’ll be lucky and happy to get one every now and then. Whatever future he decides on, Irreal wishes him the best and is happy to recognize his many contributions to Emacs and CS education.

This is a newer version of what I wrote on Sunday.

I figured a number of things.

• I’m not going to call this app at random, so I could just as well action something in Emacs when I dismiss the dialog.
• My default does not have to be selected. If it is not selected, I can use the fact that nothing is selected as the default.

So, I decided that dismissing the script would bring Emacs to the front, so that I can just write something without anything captured.

Also, I added an option to display the Capture interactive selector in Emacs, in case I want to capture something that’s not in the list (i.e., something that I would not capture that often).

I also put handlers, to kind of prettify the code.

The next step, as written in the script, is to combine that code with the “Open with Emacs” code that I have and check whether Finder is front, in which case I either open the selection or the enclosing folder.

I’ll try to not scratch that itch before I’m done with urgent work. . .

####################################

use AppleScript version "2.4" -- Yosemite (10.10) or later

use scripting additions

use framework "Foundation"

#########

# First, I'll be using the Foundation framework because otherwise it 

# would be non-trivial to find "the index of a given item in my list". 

# And for that I'll just need to use NSArrays. I did not figure that out 

# by myself, I found the hint on stackoverflow.

# reference: https://stackoverflow.com/a/65690139/5511978

#########

property NSArray : class "NSArray"

#########

# Then, I'm setting my paths to Emacs and emacsclient.

#########

set myEmacs to "/.../Emacs.app"

set myEmacsclient to "/.../Emacs.app/Contents/MacOS/bin/emacsclient"

#########

# Here, I create the list of template items I want to quickly access. I 

# have many more, but the others are more about long-form writing, so I 

# figured I'd be facing Emacs when I need to access them.

# 

# This list is basically "capture", "todo", "done", "dictionary", "notes" and "drafts".

# 

# Then I transform that into a Foundation array

#

# "capture" allows me to display the interactive template chooser.

#########

set myList to {"capture", "à faire", "fait", "dictionnaire", "notes", "brouillon"}

set myArray to NSArray's arrayWithArray:myList

#########

# Here are the template keys that I use in my Emacs interactive capture 

# template.

# Their order corresponds to the order of the above list items.

#########

set myKeys to {"c", "a", "f", "d", "n", "b"}

#########

# Now comes the interactive item selection window. That's the thing 

# that's apparently called when I call the app. All the rest takes place 

# behind the scenes.

# 

# I can just hit Enter without selecting anything.

# I'll use that to call the default template, which is "fait".

#

# I can hit the first letter of any item for it to be selected, then I 

# hit Enter to simulate clicking on OK.

# 

# The "capture" (c) key is special since it allows me to display the 

# Emacs interactive template selection dialog.

# 

# I can dismiss the dialog with either hitting Escape or clicking on 

# Cancel. But since I'm not calling the dialog by mistake, I use that 

# action to just bring Emacs to the front.

#

# I'll probably use that in a future version to call Emacs on selected 

# file and folders to open them or open dired.

#

# Then I'll need to move all that into a macOS service that I call with 

# a simple shortcut so that I don't have to:

# - call Spotlight (Cmd+Space)

# - call the app (>C)

#########

try

set captureChoice to (choose from list myList with title "Emacs" with prompt "Défaut = \"fait\"" with empty selection allowed)

set captureChoice to item 1 of captureChoice

on error

if captureChoice is false then

myEmacsComesForward()

return

end if

if length of captureChoice is 0 then

set captureChoice to "fait"

end if

end try

#########

# Here comes the place where I need Foundation's arrays.

# 

# Basically, the line says "You just selected something, find its index in the 

# list where it belongs, and get me the letter that has the same index 

# in the myKeys list."

#

# I'm adding a few parameters to see whether I'll use the contents of 

# the clipboard or not, and if I want to automatically send the template 

# key or let Emacs propose me the interactive selection dialog.

#########

set myTemplateKey to item ((myArray's indexOfObject:captureChoice) + 1) of myKeys

if myTemplateKey is in {"d", "n"} then

set useBody to true

else

set useBody to false

end if

if myTemplateKey is in {"c"} then

set interactiveCapture to true

else

set interactiveCapture to false

end if

#########

# For 2 items, "dictionnaire" and "notes", I'm thinking that I'll 

# probably have found something in a document that I'm reading, I'll need

# to copy it for use later on in the capture buffer.

# 

# In the case of "dictionary", it's a word that I want to check, and I'll 

# use that as the title of the captured item.

# 

# In the case of "notes", it's probably a sentence, or a paragraph that 

# I want to keep in the body of a captured item.

# 

# I won't use the selection for the other items.

# 

# For that, I'll put the selection (the clipboard) into the &body part of

# the org-protocol command.

#########

if useBody is true then

set myTemplateBody to "&body=" & (the clipboard)

else if useBody is false then

set myTemplateBody to ""

end if

#########

# The &body part, though, is not super clearly explained in the 

# org-mode manual:

#

# %i              The selected text

#

# Basically, the value of &body is the contents of %i in the capture template.

# I don't know why the manual mentions "the selected text" since you can put

# whatever you want in &body.

#

# In my templates, I've used it this way:

#

# ("n" "choses à noter

# → notes | à lire | code | inspiration" entry (file "~/org/memo.org")

# "* [%u]  %?\n%i" :empty-lines 0 :unnarrowed nil)

#

# Here, %i, the contents of the clipboard, will be inserted in the body 

# of the capture buffer, under the headline (notice the "\n"). And the cursor

#  (%?) is waiting for me inside the headline.

#

# or:

#

# ("d" "Dictionnaire" entry (file+datetree "/Users/suzume/org/dico.org")

# "* [%<%H:%M>] %i\n%?" :empty-lines 0 :unnarrowed nil)

#

# where %i will be inside the headline and the body of the capture 

# (supposedly the term definition) will come after the line-break, where

# the cursor is waiting for my input (%?).

#########

#########

# Et voilà !

# The org-protocol command can be built, and sent to emacsclient:

#########

if interactiveCapture is true then

set myCaptureCommand to myEmacsclient & " -e \"(org-capture)\" -n"

else if interactiveCapture is false then

set myCaptureCommand to myEmacsclient & " \"org-protocol://capture?template=" & myTemplateKey & myTemplateBody & "\""

end if

#########

# Here, I make sure that Emacs is in front of me.

# 

# If Emacs is not launched, it is now launched, which is important, 

# because my setting also starts emacs-server, without which I could not 

# use emacsclient.

#########

myEmacsComesForward()

#########

# And last but not least, the org-protocol command is sent to the 

# shell, and with Emacs at the front with the cursor waiting for me,

# I can start working right away in my capture buffer.

#########

myEmacsDoesSomething(myCaptureCommand)

#############################################

on myEmacsComesForward()

try

tell application "System Events" to tell process "Emacs" to set frontmost to true

on error

tell application myEmacs

activate

end tell

end try

end myEmacsComesForward

on myEmacsDoesSomething(myCaptureCommand)

try

do shell script myCaptureCommand

on error

log "Emacs au premier plan"

end try

end myEmacsDoesSomething

I often read complaints about how hard it is to learn Elisp and that therefore we should rewrite Emacs in Javascript or something equally silly. The fact is, of course, that Elisp, like most Lisps, is actually easy to learn and once you’ve spend a bit of time with it, you’ve got a very powerful tool for solving text manipulation problems or, really, just about any problem at all.

Marcin Borkowski (mbork) has a short post that illustrates this nicely. Mbork’s problem is a simple one. He needs to replace all backslashes with double backslashes. That’s a trivial problem in Emacs but Mbork wants to replace only single backslashes so the obvious solutions like replace-regexp don’t quite do the job. No matter, he simply wrote a bit of Elisp that, he says, took him about 6 minutes including the inevitable debugging.

Folks are fond of pointing out, correctly, that Elisp is not the best Lisp but it’s more than good enough for its domain. Sure, things like name spaces would be nice but look at this way, part of what make Elisp so easy to learn is its simplicity.

I wanted to e-mail all the EmacsConf speakers who had already uploaded their videos, and I wanted to keep track of the fact that I'd mailed them by adding a note to the :LOGBOOK: drawer in their talk heading. That way, organizers can just look at the logbook to see if we've mailed someone instead of digging through our mailboxes.

org-store-log-note assumes that it's called from the log buffer created by org-add-log-note. It doesn't seem to have a smaller function that can be called to store notes non-interactively, but that's okay. We can just set up the correct markers and call it from a temporary buffer.

(defun emacsconf-add-to-logbook (note)
  "Add NOTE as a logbook entry for the current subtree."
  (move-marker org-log-note-return-to (point))
  (move-marker org-log-note-marker (point))
  (with-temp-buffer
    (insert note)
    (let ((org-log-note-purpose 'note))
      (org-store-log-note))))

Then it's convenient to have a function that adds a note to a specified talk:

(defun emacsconf-add-to-talk-logbook (talk note)
  "Add NOTE as a logbook entry for TALK."
  (interactive (list (emacsconf-complete-talk) (read-string "Note: ")))
  (save-excursion
    (emacsconf-with-talk-heading talk
      (emacsconf-add-to-logbook note))))

I discard many drafts on the way to finalizing the process, so I want the note to be stored only after I actually send the mail. That's the job of message-sent-hook. My mail merge function calls compose-mail, sets up the body of the buffer, and then adds a lambda function to message-sent-hook to file the note in the logbook when sent.

(add-hook 'message-sent-hook
          `(lambda ()
             (mapc
              (lambda (o)
                (emacsconf-add-to-talk-logbook o "Sent speaker-after-video email"))
              (list ,@(mapcar (lambda (talk) (plist-get talk :slug)) talks))))
          nil t)

To see the mail merge code in context, you can check out the TODO entry at https://emacsconf.org/2022/organizers-notebook/#speaker-after-video . It uses functions from emacsconf.el and emacsconf-mail.el at https://git.emacsconf.org/emacsconf-el/ .

Okay, okay: I’m weak and can’t stick to even the promises I make to myself. This is yet another post on Álvaro Ramírez’s dwim-shell-command framework. Yesterday, it was combining JPEGs into a single PDF file; today it’s killing processes from within Emacs.

I really like Ramírez’s solution but not for the reason you might think. It’s nice to be able to kill a process from within Emacs but I have almost no need to that. The reason is that I spend virtually all my time in Emacs so if any process needs to be killed, it’s usually going to be Emacs. The second reason is that when I do need to kill a process, I simply click on the Apple icon and choose Force Quit from the menu. That does require the mouse but it’s quick and easy and, most importantly, works even when Emacs is the application needing killing. Still, Ramírez’s, and your, workflow is likely different from mine so it’s easy to see how this can be a good solution.

Why do I like it, then? It’s that it’s a beautiful piece of code and shows how Elisp is well up to the task of retrieving and acting on system information that we usually think of as requiring low level system programming to get at. It’s all Lisp; no cheating by dropping into C or shelling out to a system utility. It’s very nice and well worth a few minutes of study.

• Help wanted:
  • org-vcard: seeking new maintainer
  • Emacs User Survey (emacs-devel, Reddit, HN, lobste.rs)
  • Prot is asking for help to move countries
• Upcoming events:
  • CANCELLED Emacs APAC: Announcing Emacs Asia-Pacific (APAC) virtual meetup, Saturday, November 26, 2022
  • M-x Research (contact them for password): TBA https://m-x-research.github.io/ Tue Nov 15 0800 Vancouver / 1000 Chicago / 1100 Toronto / 1600 GMT / 1700 Berlin / 2130 Kolkata – Wed Nov 16 0000 Singapore
  • Hispa Emacs (virtual) https://hispa-emacs.org/ Fri Nov 18 0800 Vancouver / 1000 Chicago / 1100 Toronto / 1600 GMT / 1700 Berlin / 2130 Kolkata – Sat Nov 19 0000 Singapore
  • EmacsSF (in person): coffee.el https://www.meetup.com/emacs-sf/events/289525306/ Sat Nov 19 1100 Vancouver / 1300 Chicago / 1400 Toronto / 1900 GMT / 2000 Berlin – Sun Nov 20 0030 Kolkata / 0300 Singapore
  • CANCELLED Emacs APAC (virtual, in English) https://emacs-apac.gitlab.io/ Sat Nov 26 0030 Vancouver / 0230 Chicago / 0330 Toronto / 0830 GMT / 0930 Berlin / 1400 Kolkata / 1630 Singapore
• Emacs configuration:
  • eglot tip: build from emacs source with straight.el
  • emacs early-init.el and general tips and tricks (47:41)
• Emacs Lisp:
  • Zwitterionic digressions - Get user inputs in Emacs Lisp (Reddit)
  • [NEW] jack is a HTML renderer library for Emacs Lisp | you might find it useful (Reddit)
  • shortdoc appreciation (Reddit)
  • Xah Talk Show 2022-11-10 Emacs Lisp Write a Python Mode from Scratch, and Why Python Sucks (50:11)
  • Learn how to write an Emacs mode that highlights lines starting with the dollar sign (22:01)
• Appearance:
  • GitHub - erickgnavar/cloak-mode: A minor mode to hide sensitive values in buffers per major mode (Reddit)
• Dired:
  • GNU Emacs: Create directory in dired-mode (00:55)
  • GNU Emacs: Show/hide dot files. (00:21)
• Writing:
  • Ben Simon: Wordsmithing with Emacs (Irreal)
• Org Mode:
  • Jean-Christophe Helary: New Capture app, with org-protocol this time.
  • GitHub - mmagnus/OrgModeClockingXBar: OrgModeClockingXBar - See what you are working on ;-) [if using orgmode/clocking]​ (Reddit, emacs-orgmode)
  • Org development: ox-icalendar: Create export backend options for deadline/scheduled-summary-prefix defcustoms
• Coding:
  • [ANN] Gitstatus-el : fast and asynchronous Git status information for UI (Reddit)
  • phpinspect.el
  • Simple personal menu web page built with Emacs Lisp, Jack html generator and hyperscript (02:11)
  • XLSP Can't Save Emacs (06:57)
• Math:
  • Convert numbers in different bases with the Emacs package Calc (Reddit)
  • How to assign values to variables in Emacs GNU Calc (07:41)
  • Getting Started With GNU Emacs Calculator (calc) (09:38)
• Shells:
  • Dynamic buffer-name in term-mode | ansi-term, rename-buffer, after-change-functions, add-hook (Reddit)
• Community:
  • Weekly Tips, Tricks, &c. Thread
  • I feel stuck in my emacs learning curve.
  • Shower thoughts on how Emacs follows Unix philosophy (HN, Reddit, stormrider, Irreal))
  • Mastodon instance for Emacs users and FOSS enthusiasts (Reddit, HN, lobste.rs)
  • A parallel universe where Emacs is the popular editor (join us!) Mastodon (Reddit)
  • In the 1990s a piece of Germany’s air traffic control software ran on Emacs (2021, HN)
  • Lucid Energize Demo VHS 1993
• Other:
  • Alvaro Ramirez: Emacs: quickly killing processes (Reddit, HN, Irreal)
  • Mindmaps in Emacs - plantuml
  • New Package: tochemfig.el - Make Emacs write chemfig code from molfile or SMILES. (Reddit)
  • I added a simple hook in emacs to the GPT-3 API – actions that are a tiny complexity level above what I usually use kbd macros for (like smart capitalization) easily become possible to automate! (Reddit)
  • Installing Emacs 28.2 on a Chromebook (The Emacs Mega Tutorial Continues …) (06:57)
  • 10 Hour Emacs Compilation (09:59:07)
  • 4 Hours of Emacs (03:53:12)
  • ~declantsien/WREmacs - sourcehut git WebRender (Reddit)
• Emacs development:
  • progress on tree-sitter support for C-like languages (earlier)
    • emacs-devel: notes on tree-sitter and c-sharp
    • things to extract from cc-mode
  • Shorthands discussions:
    • A short defense of shorthands.el (but CL packages are still better)
    • the story from the beginning
    • shorthands doesn't negate the need for cl packages; (complications with backwards compatibility)
    • more discussion of challenges
  • * lisp/minibuffer.el (set-message-functions): New user option.
  • Add to /etc/NEWS a mention of the new C++20 support in CC Mode
  • ; * etc/NEWS: Mention that order of overlays might change. (Bug#59067)
  • EUDC: Add ecomplete and mailabbrev backends
  • EUDC: Add eudc-ignore-options-file customization
• New packages:
  • beans: Major mode for Beans grammar (MELPA)
  • corfu-prescient: Corfu integration (MELPA)
  • flymake-elisp-config: Setup load-path for flymake on Emacs Lisp mode (MELPA)
  • gitstatus: Common front-end for `gitstatusd' (MELPA)
  • glue: Emacs - Common Lisp interop using SLIME or SLY (MELPA)
  • jarchive: Open project dependencies in jar archives (GNU ELPA)
  • lurk-mode: A major mode for editing lurk files (MELPA)
  • ob-lurk: Evaluate lurk code blocks in org mode (MELPA)
  • org-rainbow-tags: Colorize org tags automatically (MELPA)
  • ptree: Property tree data structure (MELPA)
  • vertico-prescient: Vertico integration (MELPA)
  • zk-desktop: Desktop environment for zk (MELPA)

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

Now that the kiddo's reasonably well-settled into virtual school and EmacsConf is chugging along nicely, I finally have a little time to explore Mastodon, a federated social network that quite a lot of people have been shifting to (and quite a lot of people have been on all along). When @louis@emacs.ch e-mailed me about including the new emacs.ch Mastodon instance in Emacs News, I figured I'd set up a profile for myself and have a look around.

I like to keep an eye on posts mentioning Emacs once in a while, which might be a little more complicated than it is on Twitter given the distributed nature of Mastodon. Anyway, if you post something you'd like me to include in Emacs News, please mention me at @sachac@emacs.ch. Thanks!

I've also set up a bot that posts things from planet.emacslife.com. It's at https://emacs.ch/@emacslife .

I tend to scroll through Mastodon on my phone or using mastodon.el, which is really nice for keyboard navigation.

See y'all there!

I keep promising myself that I’m not going to publish anymore posts about Álvaro Ramírez’s dwim-shell-command articles but he keeps finding compelling new applications for it. The latest is a problem I often have: combining several JPEG images into a single PDF. For me, this usually comes up when I want to combine several receipt images—a bill and credit card receipt, for example—into a single PDF for tax purposes. That comes up all the time in my workflow and Ramírez’s simple application makes it easy.

Ramírez’s post is a useful one if you aren’t aware of the dwim-shell-command framework because he lists all the applications that he’s made/discovered for the it. If, like me, you like to stay within Emacs but sometimes (or often) need to run some application from the command line, dwim-shell-command is just what you need. That’s especially true if the command has a complicated, hard to remember syntax. You encapsulate all the complexity in a simple Emacs function and invoke it from within Emacs. What could be better?

Just about 5 years ago, I wrote a Capture (really) everywhere article where I described a simple AppleScript application that could be launched from Spotlight and that would call org-capture in a running instance of Emacs.

I had a really nice time with that app, until sandboxing became stricter, and it became difficult to reliably control applications with keystrokes sent from System Events.

I eventually rewrote the application, and it basically became a simple call to emacsclient:

set myCaptureCommand to myEmacsclient & " -e \"(org-capture)\" -n"

do shell script myCaptureCommand

Here again, the app worked well, and I could enjoy spending time crafting org-capture templates, like everyone else does when not capturing things.

Then, it occurred to me that instead of

• calling Spotlight,
• calling >Capture.app,
• hitting the template key in Emacs,
• capture my things,

I could create specialized little apps that would call a given template that I often use. Like the "fait" (done) template that I use a number of times during the day to write down what I've accomplished so far.

I started investigating in that direction, trying to use various org-capture options, but I could not make it work. Then I found a number of interesting articles that helped me figure out my new solution: 

• How to use org-capture from system tray (2016)
• Some Uses for Org-Protocol (2022)
• The capture protocol (the org-mode manual)

When I read that I could use the org-protocol to set the template key, I immediately thought that I could implement a little interactive template selector in AppleScript that would automatically put me in the right capture buffer.

And that's what I've been doing today, and I'll properly document that in my daily log, with that application, when I'm done with this article...

So, first, here is the app. It's just out of the oven, it works, I've not tested it extensively, so there might be glitches here and there, but it looks OK.

The main difference is that I'm using emacsclient to work with org-protocol here, instead of having it evaluate a call to (org-capture).

When I call it, it displays the following list item selector:

If I have copied something from a document on my machine, the copied contents will be used in the headline for "dictionnaire":

Here, I had copied "統一教会" from an article I was reading, to gather notes about the organisation.

And the copied contents will be used in the body of the capture buffer if I selected "notes":

Here, it is a short article about 伊藤詩織 and her recent win in court. Now I just have to put a title and eventually write more about the item.

As usual, the explanations come as comments in the AppleScript code so that you can just copy-paste the thing and test it. Although in this case, there are many things that depend on my setup that I doubt it would work out of the box.

####################################

use AppleScript version "2.4" -- Yosemite (10.10) or later

use scripting additions

use framework "Foundation"

#########

# First, I'll be using the Foundation framework because otherwise it 

# would be non-trivial to find "the index of a given item in my list". 

# And for that I'll just need to use NSArrays. I did not figure that out 

# by myself, I found the hint on stackoverflow.

# reference: https://stackoverflow.com/a/65690139/5511978

#########

property NSArray : class "NSArray"

#########

# Then, I'm setting my paths to Emacs and emacsclient.

# Change the values to something that works for you.

#########

set myEmacs to "/path/to/Emacs.app"

set myEmacsclient to "/path/Emacs.app/Contents/MacOS/bin/emacsclient"

#########

# Here, I create the list of template items I want to quickly access. I 

# have many more, but the others are more about long-form writing, so I 

# figured I'd be facing Emacs when I need to access them.

# 

# This list is basically "todo", "done", "dictionary", "notes" and "drafts".

# 

# Then I transform that into a Foundation array

#########

set myList to {"à faire", "fait", "dictionnaire", "notes", "brouillon"}

set myArray to NSArray's arrayWithArray:myList

#########

# Here are the template keys that I use in my Emacs interactive capture 

# template.

# Their order corresponds to the order of the above list items.

#########

set myKeys to {"a", "f", "d", "n", "b"}

#########

# Now comes the interactive item selection window. That's the thing 

# that's apparently called when I call the app. All the rest takes place 

# behind the scenes.

#

# That's the thing that you see above in the first screenshot.

# 

# I can hit the first letter of any item for it to be selected, then I 

# hit Enter to simulate clicking on OK.

#########

set captureChoice to item 1 of (choose from list myList with title "Capture" default items "fait" with prompt "Choix")

#########

# Here comes the place where I need Foundation's arrays.

# 

# Basically, the line says "You just selected something, find its index in the 

# list where it belongs, and get me the letter that has the same index 

# in the myKeys list."

#########

set myTemplateKey to item ((myArray's indexOfObject:captureChoice) + 1) of myKeys

#########

# For 2 items, "dictionnaire" and "notes", I'm thinking that I'll 

# probably have found something in a document that I'm reading, I'll need

# to copy it for use later on in the capture buffer.

# 

# In the case of "dictionary", it's a word that I want to check, and I'll 

# use that as the title of the captured item.

# 

# In the case of "notes", it's probably a sentence, or a paragraph that 

# I want to keep in the body of a captured item.

# 

# I won't use the selection for the other items.

# 

# For that, I'll put the selection (the clipboard) into the &body part of

# the org-protocol command.

#########

set myTemplateBody to ""

if myTemplateKey is in {"d", "n"} then

set myTemplateBody to "&body=" & (the clipboard)

end if

#########

# The &body part, though, is not super clearly explained in the 

# org-mode manual:

#

#  %i              The selected text

#

# Basically, the value of &body is the contents of %i in the capture template.

# I don't know why the manual mentions "the selected text" since you can put

# whatever you want in &body.

#

# In my templates, I've used it this way:

#

# ("n" "choses à noter

# → notes | à lire | code | inspiration" entry (file "~/org/memo.org")

# "* [%u]  %?\n%i" :empty-lines 0 :unnarrowed nil)

#

# Here, %i, the contents of the clipboard, will be inserted in the body 

# of the capture buffer, under the headline (notice the "\n"). And the cursor

#  (%?) is waiting for me inside the headline.

#

# or:

#

# ("d" "Dictionnaire" entry (file+datetree "/Users/suzume/org/dico.org")

# "* [%<%H:%M>] %i\n%?" :empty-lines 0 :unnarrowed nil)

#

# where %i will be inside the headline and the body of the capture 

# (supposedly the term definition) will come after the line-break, where

# the cursor is waiting for my input (%?).

#########

#########

# Et voilà !

# The org-protocol command can be built, and sent to emacsclient:

#########

set myOrgProtocolCommand to myEmacsclient & " \"org-protocol://capture?template=" & myTemplateKey & myTemplateBody & "\""

#########

# Here, I make sure that Emacs is in front of me.

# 

# If Emacs is not launched yet, it is now launched, which is important, 

# because my setting also starts emacs-server, without which I could not 

# use emacsclient.

#########

try

tell application "System Events" to tell process "Emacs" to set frontmost to true

on error

tell application myEmacs

activate

end tell

end try

#########

# And last but not least, the org-protocol command is sent to the 

# shell, and with Emacs at the front with the cursor waiting for me,

# I can start working right away in my capture buffer.

#########

try

do shell script myOrgProtocolCommand

on error

display alert "ooops"

end try

#############################################