Irreal

Álvaro Ramírez is back with the second video in his new series. This video is about making some simple UI adjustments to Emacs to bend it into looking and acting in a way meets your needs. That doesn’t sound too exciting except that Ramírez shows all this by doing something that many of us will find useful: He starts a separate Emacs instance and arranges for the changes he specifies in the first instance to appear in the second instance.

That’s actually easier than it seems. Starting the second instance is just a matter of calling Emacs with some command line arguments to specify where to find init.el and where to put temporary Emacs variables, such as the lock files and socket pointers. If you need to invoke independent instances of Emacs, it’s probably worthwhile capturing the command into an Emacs function or shell script.

Arranging for commands to take place in the second instance is also easier than you might think. For that Ramírez defines a macro that takes the command as an argument and makes a call to the other instance via emacsclient asking it to execute the command. If that sounds mysterious, take a look at the code. It’s straightforward and easy to understand.

Looking at the code for all these snippets is easy because Ramírez has it all in a blog entry. You can capture the code for invoking another Emacs instance and the macro for sending commands to it and use them in your own work.

The particular customizations that Ramírez makes are beside the point. They’re what works for him and even if you want to steal some of them, your ideal Emacs UI almost certainly differs. The real value of his video, I think, is that it shows you an easy way to set up an environment to try prospective changes.

The video is 14 minutes, 37 seconds so it should be reasonably easy to fit into your schedule. It’s definitely worth 15 minutes of your time.

Ashton Wiersdorf has a nice post on how he organizes papers, notes, and citations for his research. Of course, Emacs is at the center of that process and it’s another aspect of Emacs use that fascinates me. A couple of weeks ago I wrote about Kiran Gopinathan’s method of doing paper reviews, which overlaps considerably with Wiersdorf’s post. Two and a half years ago, I wrote how John Kitchin does the same thing.

Wiersdorf is a self-described Emacs maximalist but he is, nevertheless, also a heavy Zotero user. I’ve written about Zotero many times before. It a package for storing, managing, and building the bibliographies for papers. See this Wikipedia article for details. Wiersdorf’s post describes how he combines Zotero and Emacs to manage his research papers.

He also recommends the citar package for handling citations. John Kitchin’s Org-ref is another excellent choice for this but the citar package works well with Zotero. Lots of folks swear by Zotero and if you’re one of those people, citar may be for you.

The other major package that Wiersdorf uses is Protesilaos Stavrou’s Denote. He describes it as a Zettelkasten-like package. Gopinathan uses Org-roam for the same thing so you should take a look at both packages to see which you like best.

Finally, Wiersdorf uses the citar-denote package to integrate denote and citar. It ties citar and denote together and allows you to easily access papers from their citation. Take a look at Wiersdorf’s post for some details.

The most important thing, Wiersdorf says, is to use Emacs to build your own system. It’s not an editor, he says, but a toolkit to build your ideal editor. That’s differs a bit from my usual definition but is certainly a good description. Regardless, the goal is to make Emacs into an editor that meets your exact needs.

Chris over at Entropic Thoughts has some thoughts on blogging and Emacs. He’s conflicted. On the one hand, he yearns for a simple, static blog generator that he can understand. On the other hand, he uses Org Babel a lot and it’s an important part of his blogging workflow, which involves generating graphs in R for a lot of his posts.

He’d like to write a simple blog exporter that he understands and can modify but feels that it’s too hard to include the Org Babel functionality. I feel his pain. I use WordPress for Irreal and although it mostly works well, I sometimes wish I had a simple static generator that didn’t depend on a complicated infrastructure like WordPress. But every time I look into it, the effort doesn’t seem worth the gain and, as I say, WordPress mostly does a good job of meeting Irreal’s needs.

On the positive side, I do write my blogs in Org mode and have access to all its tools. Before my provider started blocking the XML-RPC protocol, I simply used Org2blog, which took an Org buffer and took care to exporting it directly to WordPress. These days I have a slightly more complicated process. I have a command that converts my Org buffer to HTML and saves it to the clipboard. Then I invoke WordPress and paste the HTML into its HTML input buffer. That’s not ideal but it’s pretty simple and I certainly understand it, at least until I push the WordPress publish button. Every once in while I try publishing with Org2blog because that is truly easiest way to go from Org to WordPress. Maybe I try that with this post.

In any event, it is possible to publish directly from Org even to a static blog fairly easily simply by converting the buffer to HTML and then doing whatever yo need to do to push it to your site.

Álvaro Ramírez is trying a different way of communicating his ideas and projects to us. He has a new YouTube channel for this and has posted his first video, Bending Emacs – Episode 1.

It’s a very nice step-by-step explication of how to use his DWIM shell command to translate one or more video files to animated GIFs. I first wrote about DWIM shell command three years ago and have mentioned it several times since.

This problem was just what DWIM shell command was developed for: getting a handle on the complexity and confusion of FFmpeg command line options. Even though Ramírez does this sort of thing all the time, he has trouble remembering all the FFmpeg options. For this particular project he fell back on relying on an LLM to give him the magic formula but if you’re not an AI user, you can always read through the documentation.

After that, it’s a simple matter of using DWIM to capture the process. Ramírez also shows how to capture the process as an Elisp function so that it can be invoked seamlessly from Emacs whenever it’s needed.

Those of you who like to get your tech hits visually will enjoy this video. The blog post has a good précis of the video and the video itself is only 6 minutes, 15 seconds long so it’s easy to fit into your schedule.