Irreal

Grant Rettke has his own take on a function to enable narrowing to multiple regions of a buffer. I learned about the idea from comments to a post on another matter and wrote about it here. Rettke takes the example functions that I wrote about and adjusts them to suit his own needs.

I really like that this idea is getting more exposure. As Rettke says, all the ideas are there in the Emacs manual but it takes guys like Zane Ashby to see how they can be used to solve a particular problem. I also like Rettke’s characterization of the problem as a sort of “semi-literate programming.” It seemed strange when I first read it but that’s exactly what’s going on: you can treat different parts of the buffer in different ways to create a whole.

If you want another take on the functions that Zane and grayswx wrote, head on over to Rettke’s post and take a look.

Update: Retkke → Rettke. Sorry Grant.

Today I learned something new from a short post on Xah Lee’s blog. The idea is that you’ve written a command that generates output in a temporary buffer and you want to enable the undo function for the buffer so that the user can edit the buffer with undo capabilities.

You can’t link to individual posts on Lee’s blog but you can search for the date of the post, which is 2014-05-30. Here’s the code from that post in case you have trouble finding the post:

(with-output-to-temp-buffer outputBuffer
  ;; …
  (switch-to-buffer outputBuffer)
  (setq buffer-undo-list nil )          ; enable undo
  )

As you can see, it’s merely a matter of providing an empty buffer-undo-list for the buffer. This isn’t the sort of thing you’re going to need very often and it would probably be pretty hard to find it in the documentation¹. So this post is mainly a note to myself although I hope it might help others who didn’t know this fact.

Most of my posts are pretty short: maybe 250 words or so. The other day, I began to wonder how long the average post is so I wrote a few lines of Elisp code and just executed it in the scratch buffer.

Here’s the code:

(let ((posts 0) (words 0))
  (mapc (lambda(p)
          (with-temp-buffer
            (insert-file-contents p)
            (goto-char 1)
            (setq words (+ words (how-many "\\w+")))
            (setq posts (1+ posts))))
        (directory-files "~/org/blog" t ".*\\.org"))
  (format "Total words: %s, Average per Post: %s" words (/ words posts)))

As you can see there’s nothing special in it. The only points worthy of note are the use of with-temp-buffer and =insert-file-contents instead of find-file, a trick I learned from Xah Lee, and the use of directory-files, which is a nice way of getting a list of files satisfying some regex.

When I run the code I get

Total words: 362460, Average per Post: 303

so my posts are a bit longer than I thought. It’s also interesting that in the 3 years I’ve been posting to Irreal, I’ve written about 360,000 words or 120,000 words a year. That’s about a novel’s worth of words a year. Now if I could only write a novel.

If you write Emacs functions—even for yourself—you are, of course, including a docstring. Functions have a way of escaping from your init.el and finding their way to someone else’s config. Even if that doesn’t happen you may find yourself happy to have a reminder of the function’s details. At least if you’re like me.

It turns out that docstrings have their own mini-markup language. Xah Lee has a nice tutorial on how to use that markup language. I find Lee’s post clearer and easier to read than the Documentation Tips page of the Elisp Manual.

The Emacs built-in documentation is nicely formatted and, when properly done, very useful. Most times, it’s all you need to use a command, function, or variable successfully. By learning and using the markup language that docstrings provide, you can document your code as nicely as the built-in functions.