Emacs For Everything

Joshua Blais has an interesting post that looks at the idea of using Emacs for everything. That’s a familiar meme for us Emacsers, of course, but you don’t often see a careful, considered examination of the idea. Blais is an Emacs user so his post is, naturally, supportive of the idea but he does try to give both sides of the issue.

Blais’ main argument is built around the flow concept. Interrupting a knowledge worker’s flow can have devastating effects on their productivity. These interruptions include context switches and one study suggests that context switching and multitasking takes up around 60% of our working time. That seems high to me but whatever the value, it’s certainly significant.

One of the virtues of Emacs is that virtually all your text based tasks can be done in Emacs. That’s significant because the editor provides a uniform interface to all those tasks. Indeed, you can even slip it into other apps with packages like Emacs Everywhere that allow you to bring up an Emacs window to edit some app’s text area. For example, I use it with iMessage so that I can compose my texts in Emacs.

The advantage to doing most things in Emacs is that you avoid context switches and can better stay in the flow. A secondary benefit, as least for me, is that it provides a single set of muscle memories to deal with. As I’ve said before, I do better with a single set of keybindings so folding everything possible into Emacs is a win for me.

Blais also considers and dismisses the argument that Emacs takes so long to learn that you never regain the time “lost” to learning it. Even a few seconds thought is enough to recognize that idea for the silliness it is but Blais makes the point that if you aren’t using Emacs you’re still spending time learning other utilities that Emacs would otherwise handle. I know this first hand. Before I came to Emacs I was a long time command line user and spent years learning to use it effectively. Now I rarely use the command line; everything I need to do I can do from within Emacs.

Blais’ post is well worth a few minutes of your time whether or not you’re an Emacs user. Take a look.

Posted in General | Tagged | Leave a comment

AI And Em Dashes

My old colleague and friend Watts Martin has an interesting and amusing post on em dashes and their indication of AI generated text. As many of you know, Irreal is an em dash friendly site [1, 2, 3, 4] and we spend a good portion of our pixel budget on them.

I was, therefore, surprised to discover from Martin’s post that according to LinkedIn influencers, real people don’t use em dashes—they use hyphens—and therefore em dashes are a sure sign of AI generated text. Once I got over the notion of a “LinkedIn influencer” and what that could possibly mean, I read Martin’s explanation for this bizarre and clearly erroneous belief.

His explanation would make a fine Red Meat Friday post. The TL;DR is that LLM AIs are, by and large, trained on polished text where the use of em dashes is natural and common, whereas, sadly, many people can’t write at all. That is, their reading and writing is restricted to things like emails or business memos that haven’t had the benefit of even a first editing pass, let alone a final polishing. Most of these people don’t read enough “good” writing to even know what it looks like.

Those of us who do use em dashes should feel flattered. We are, apparently, at least as good at writing as the current AIs. Of course, I’d prefer the comparison to be to Iain M Bank’s Minds—this is Irreal, after all.

Posted in General | Tagged | Leave a comment

Scrim Beta

Charles Choi, someone whom Irreal often writes about, has a new app and is looking for beta testers. His app, scrim, is a way of making the org-protocol available to macOS users. The problem is that org-protocol depends on the ability to call emacs-client from within the invoking application but security rules on recent macOS versions make this difficult or impossible. Take a look at the scrim link for a fuller explanation.

Becoming a beta tester is really easy. All you have to is install TestFlight and choose the Scrim app. My experience with TestFlight has been outstanding. It automates virtually everything including keeping you up to date with the latest beta version.

The only app I ever want to export data from is Safari and I have some custom AppleScript code to handle that. Still, if I were starting today I would probably try to use org-protocol to solve the problem for any application supporting the share menu.

If you want to import data from other applications into Emacs or think that being able to do so would make your workflow smoother, take a look at Choi’s post and consider becoming a beta tester. If you are already a Captee (Choi’s previous application for this) user you should especially consider this.

I can tell you from my own experience with being a beta tester for Journelly, that it’s a rewarding and beneficial activity. You not only get an early look at an application but can also influence its final form. And, of course, you help the developer deliver the best possible app.

Posted in General | Tagged , | Leave a comment

Emacs And Lisp

Joe Marsahll has been blogging up a storm lately. One of his latest posts is a sort of personal history of Emacs and its relationship to Lisp. When Marshall started as an undergraduate, he was using the line oriented editor TECO. If you think your experience with an editor is difficult, read his description of what it was like to use TECO.

Soon he was directed to Vi and a whole new world was opened to him. He no longer had to work in the blind but could actually see what he was doing. Later, when he moved to MIT he was introduced to Lisp and various early incarnations of what we now think of as “Emacs”.

Emacs, of course, began life as a set of macros for TECO so, in a sense, Marshall revisited TECO when he started working at the MIT AI lab. but the Lisp Machines that were developed in the AI lab had their own Emacs clone integrated into the system. In his career he has used a wide variety of Emacs-like editors but like all of us he’s using GNU Emacs these days.

One of the things Marshall talks about is using Sly with Emacs to recreate his experiences on the Lisp Machine. Sly, he says, pretty much recreates the interface that you had using ZWEI—an early version of Emacs—on a Lisp Machine. I’m still using Slime for my Lisp coding but, as I have written many times, I have a long standing urge to work on a Lisp Machine so I may give Sly a try if only to get closer to the Lisp Machine experience.

Posted in General | Tagged | Leave a comment

Prot On Elisp

If you follow the various Emacs forums, you’ll see a lot a whining about how hard Elisp is to learn and how things would be so much better if only the extension language were something rational like Python, Ruby, or Lua. I rail frequently against this nonsense but Prot (Protesilaos Stavrou) stands as an unassailable refutation of the silliness.

He’s a guy with a liberal arts education who has no training in programming and yet has nevertheless produced some really great Emacs software. If you look at his code, you can see that he’s obviously mastered the intricacies of Elisp.

Now, Prot has shared some of his knowledge in the form of a short Elisp tutorial. Although Emacs is exhaustively documented, there’s a dearth of Elisp documentation for beginners. There is, of course, the Elisp manual, which is comprehensive, but not really beginner friendly. It’s a reference rather than a tutorial.

There’s the builtin Elisp tutorial and Mbork’s Elisp book but not much more. I am, therefore, happy to see Prot’s contribution. I haven’t had a chance to do more than scan it but it seems like a very worthwhile addition to the Emacs corpus.

One thing for sure, it should put all the whiners to shame. If you’re claiming to be a software engineer but find Elisp too difficult to learn, you should be chagrined that a guy with no formal training in software is nevertheless able to produce first rate Elisp code that the Emacs community embraces as useful and excellent.

The irony is that Lisps in general are actually easier to learn and use than other languages. It’s just that they’re unfamiliar to n00bs so they seem unapproachable. If you just suspend your expectations from other languages, you’ll find that Elisp is actually an easy language to learn.

Update [2025-04-13 Sun 16:24]: Added link to Prot’s book.

Posted in General | Tagged , | Leave a comment

An Application Of Bloom Filters At Google

Joe Marshall, who is an old time Lisper now working at Google, has an interesting story about the use of Bloom filters at Google. The story begins when Marshall noticed an anomaly in the response time graph of one their search appliances. There was an odd blip at 300 ms across several machines that was independent of the search string.

Marshall soon narrowed the problem to the spell server that asks you “Did you mean X” when you misspell a word in your search string. Here’s how that works. When you enter a search string, each word is checked to see if it’s in the list of “known misspellings of legitimate terms”. This is done by means of a Bloom filter. The thing about Bloom filters is that if they tell you an item is not in the list then that item is definitely not in the list. But if it says the item is in the list, the item may or may not be there. If a spell server term is flagged as a misspelling, a longer running process is invoked to find the misspelling and suggest alternatives. Obviously, misflagged terms increase response time.

A good Bloom filter is designed so the probability of a false positive is minimized. Marshall gives the basic idea of Bloom filters but they’re actually a bit more complex because they use multiple hash functions. Still, his explanation tells you what you need to know: It basically hashes each word into a bit array that is false if the term is not there, and true if any term hashed to that bit location. Obviously the bigger the bit array, the less chance of a collision. You can check the linked Wikipedia article if you want the details.

Marshall’s problem turned out to be that the bit array wasn’t big enough so even correctly spelled words were being flagged. When he increased the bit array size the problem went away and the 300 ms blip disappeared.

Posted in Programming | Leave a comment

Configuring Journelly

After my post Initial Thoughts On Journelly, in which I recounted how I’m using Álvaro Ramírez’s Journelly app, Bren Smith asked me to share my configuration for sharing files between my iOS devices and my Mac. If you’re an Emacs user and want to enjoy the full power of Journelly, it’s important to be able to share the files between your iOS devices and your Macs.

The thing is, it’s so easy that it didn’t occur to me an explanation was needed. By default, Journelly keeps all its files locally on your phone or other iOS device but it’s possible to store them in the iCloud or, really, anywhere that’s reachable from your Mac and your iPhone/iPad. If you click on the three dots at the upper right of the Journelly screen and then choose Storage → iCloud Drive, Journelly will allow you to store your files in the iCloud. From there you can easily access them from your Mac.

Apple’s default location for storing the files is a long and complex file spec so you’ll probably want to set a symbolic link to it so that it’s easy to access from the Mac. Once you’ve done that, it’s easy to bring up the Journelly file in the usual way from Emacs or any other app.

It’s also possible to put the files somewhere else in the iCloud by using the Storage → Other… option. I did this so I wouldn’t have to navigate the complex file spec but in the end, it turned out to be easier to just set a symbolic link so I recommend you just use the Storage → iCloud Drive option. On the other hand, I think, but haven’t verified, that you can use Storage → Other… to store the files anywhere you like but I don’t know the details.

The other thing to keep in mind is that Journelly is still in beta so any or all of this could change. Still, I’ve been using this setup every day without any problems.

Posted in General | Tagged , | Leave a comment

Another Happy Journelly User

As you all know by now, I’ve become a huge Journelly fan. Its author, Álvaro Ramírez, thinks of it as Twitter for your private use. That’s a reasonable description given its user interface but it doesn’t begin to capture its real power.

As more and more users have started using the beta, I’ve come to realize that Journelly is a bit of a shape shifter that adapts itself to your needs. Ramírez, apparently, just wanted a simple app that he could use like a private Twitter. My use case is implementing my memo book. I want to capture entries on my phone and keep the results as a permanent record of my daily activities.

JTR over at The Art Of Not Asking Why has a different conception. He is using it as a sort of staging area for capturing notes that he then refiles to the appropriate Org files. That’s possible because one of Journelly’s strengths is that it keeps its data in Org format and can arrange to sync its files with your Mac and other iOS devices.

JTR explains all this in his latest post on Journelly in which he reveals himself as another happy Journelly user. It’s a nice post that recounts his experience with using Journelly. As I say, his use is slightly different from mine but that just speaks to the power and flexibility of Journelly. If you’re the slightest bit interested in Journelly, you should read his post.

About the only thing I don’t agree with is that JTR says that if you’re not an Emacs user, you should probably look elsewhere. Journelly is such a good fit for my memo book that I’d probably use it even if I weren’t an Emacser. But, of course, I am and the fact that its records are in Org format just expands its power for me. As Jack Baty says in a comment to JTR’s post,

I think he things of the .org thing as an implementation detail, so as to not limit his audience, but you’re right, for me it’s The Thing™.

The other thing that JTR mentions that I forgot to write about is that after tapping the big plus sign, you can enter your note orally in the usual iOS way. That’s really powerful, especially when you’re on the run.

Posted in General | Tagged , | Leave a comment

Twenty Years Of Git

Wait. What? Git is 20 years old? How can that be? I’m sure it was just yesterday that Linus announced the Git project after his arrangement with Larry McVoy’s BitKeeper imploded. That’s a sad story in itself but this post is just about how surprised I am that Git is 20 years old.

I started using Git fairly early on and soon after it became available, I moved to Magit. In the intervening years, Git has taken over the VCS mindspace. At this point, virtually everyone without very special requirements uses it.

There’s an argument to made that BitKeeper is the better solution and McVoy has made that argument in the past but BitKeeper was proprietary software in an age when developers pretty much insisted on open source tools. McVoy, to his credit, has accepted this and is devoting his time to fishing.

Whether or not Git is the best solution it has emerged as the default solution and that, I think, is a good thing. It’s definitely a good VCS and having a standardized VCS benefits us all. I have no doubt that its distributed nature is the correct answer and 20 years of Git and BitKeeper before it has proven that to be the case.

The article that I linked above has a nice history of Git and its origins. If you weren’t there to experience it, you may enjoy discovering some of that history

Posted in Programming | Tagged | Leave a comment

Emacs Startup Time

Bozhidar Batsov has a post that claims something I’ve often said: Emacs startup time doesn’t matter. No one is saying that your editor taking 30 seconds to start is acceptable but by and large the people you see worrying about startup times are obsessing over sub-second differences. That is, differences that are virtually imperceptible to a human at the keyboard.

Batsov and I say that if you’re using Emacs correctly, you hardly ever restart it. Unlike, say, Vim, you shouldn’t start a new Emacs session for each file you want to edit. When I switched from Vim to Emacs, this was one of the hardest things to get used to. Even if you do want to invoke Emacs for each file, you can simply use Emacsclient and get near instantaneous response.

Judging from the comments on reddit, you’d think Batsov had resurrected Swift’s Modest Proposal. He was accused of being arrogant and not understanding how “real” people use Emacs. If you know anything about Batsov, you’ll find that an amusing notion.

Sure, people do use Emacs in different ways and for different reasons. One commenter, for example, says he develops packages and often has to restart Emacs. John Wiegley does the same but he was a separate Emacs that starts quickly to deal with that: when you’re testing a package you probably want something approaching Emacs -Q anyway.

The TL;DR is that for almost everyone, Emacs startup time really doesn’t matter. I restart Emacs once a week when I upgrade my packages. Batsov says that he goes months without a restart. Even if Emacs did take 30 seconds to start, why would we care. One commenter complains that he has to restart Emacs every morning and, therefore, startup time really does matter. Sorry, but that’s just silly. If you have to spend 5 seconds—or even 30 seconds—starting Emacs in the morning, who cares?

And, by the way, if Emacs really is taking more than a few seconds to start, it probably means that there’s something wrong with your configuration. Mine has plenty of packages, hasn’t been refactored since I started almost 20 years ago, and it still starts within a couple of seconds. It’s hard to get a hard number because it stops to ask me for a password for my .authinfo file. I’m inclined to think of it like booting my machine: it’s not instantaneous but I don’t do it very often.

Posted in General | Tagged | Leave a comment