The PhD Movie

Posted on 2014-06-07 by jcs

If you’ve been a graduate student since the late 1990’s, you’re probably familiar with PhD Comics, a comic drawn by Jorge Cham that captures the absurdities of his graduate studies in a way that will resonate with any graduate student. If you have graduate student experience and haven’t seen PhD Comics, you should definitely add it to your daily reading list.

A couple of years ago, Cham recruited some graduate students to make a movie that captures some of the fun of the comic. It’s about an hour long and has been for sale since its release. Now Cham is raising funds for a second movie and as part of that effort you can view the first movie for free during June. Just go to this page to enjoy the fun. It’s amazing how well the actors capture the comic’s characters.

You probably have to have been a graduate student to appreciate the in-jokes and humor of the movie but if you have that experience, the movie is sure to bring back those days of joy and pain. I love this comic and read it every day and I really enjoyed the movie. Now’s your chance to see it for free.

If you like it or are a PhD Comics fan, you might want to kick in some funds for the new movie. Just follow the second link above for the kickstarter page.

Posted in General | Leave a comment

Magnar Continues His WebRebels Videos

Posted on 2014-06-06 by jcs

The estimable Magnar Sveen has, to use his words, come out of hibernation and continued the posting of his WebRebels talk. This video is part 5 of the series.

It’s been a while so if you don’t remember, the official video of the talk had technical problems but Sveen has recreated it bit by bit. If you’ve never seen Sveen talk, it’s a real treat. He’s an excellent speaker and his mastery of Emacs is impressive.

He’s most known for his spectacular Emacs Rocks! videos. If you’re an Emacs user and haven’t watched them, stop right now and have a look. His original talk at the Oslo WebRebels is astounding and you should definitely watch it too. You can get links to the other videos for the current WebRebels talk at this page.

If you like these videos and want to learn a bit more about Sveen, Sacha Chua interviewed him in one of her Emacs Chats.

Posted in General | Tagged | Leave a comment

Mutable String and Emacs Buffer Passing Style

Posted on 2014-06-05 by jcs

Speaking of Christopher Wellons, he’s got a very interesting post over at null program on mutable strings and Emacs buffer passing style. Wellons starts by pointing out that strings in Emacs Lisp, like many other languages, have a fixed size and any operation that changes the size requires that a new string be allocated and current content copied into it. That can be a problem when you’re building up a string incrementally. Next, he observes that Elisp has a natural character-oriented data structure: buffers. Why not use a buffer to build up the string components and then turn the buffer into a string with buffer-string. Something along the lines of: 

(with-temp-buffer
  ;; build up the string
  (buffer-string))

That’s a good tip all by itself but Wellons goes further.

Suppose you are writing a function to construct a string. A natural technique is to have the function build the string in a buffer and then pass the buffer back to the caller who can do whatever they need with it (perhaps never coercing it into an actual string). The problem is that using that method makes it easy to leak buffers, which are not garbage collected. Wellons has a nice example of how that can happen in his post.

To avoid this problem, Wellons advocates what he calls a buffer passing style. With this approach, a buffer is implicitly passed to the function, which fills it with the desired data. “Implicitly” because the caller arranges for the current buffer to be the buffer that the function uses. Then the caller can kill the buffer after using the data. The actual idiom is something like: 

(with-temp-buffer
  (fill-buffer-with-desired-data)       ;string building function
  ;; process the data
  )

This is nice because the with-temp-buffer macro takes care of killing the buffer when you reach the end of the macro body.

Take a look at Wellons’ post. It’s very informative and gives some fleshed out, realistic examples rather than the skeletons I give here.

Posted in Programming | Tagged , | Leave a comment

Sacha Chats with Christopher Wellons

Posted on 2014-06-04 by jcs

The invaluable Sacha Chua has posted another in her series of Emacs chats. This time it’s with Christopher Wellons. As regular readers know, I’m an admirer of Wellons and have written about him several times (1, 2, 3, 4, 5).

As usual, they talk about Wellon’s work flow, his Emacs configuration, and his projects. As you can see from my previous posts on Wellons, he’s the type of guy who is always working on little, interesting projects that often grow into something really useful. Watch the video to get an idea of what those projects are. Chua has a handy list of links to them on Github so that you can explore them after watching the video.

One of the things that I really liked was his with-package and with-package* macros. They make sure that your packages are loaded and that any package specific actions are taken at the proper time. I really like this because it provides a way of listing the packages you use in your init.el or .emacs file and then they get loaded automatically if they aren’t already on your machine. Right now, I do this manually for each of my machines and that’s just silly and error prone.

Wellons says that the macros are a little rough but I found them perfectly reasonable and the code is very nice as well. I’ll be integrating them into my own configuration directly.

The chat is just under 57 minutes so plan accordingly. It’s a great chat and one you won’t want to miss.

Posted in General | Tagged | 2 Comments

Grant Rettke’s Take on Narrowing to Multiple Regions

Posted on 2014-06-03 by jcs

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.

Posted in Programming | Tagged | Leave a comment

Turning On Undo in a Temporary Buffer

Posted on 2014-06-02 by jcs

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 documentation1. So this post is mainly a note to myself although I hope it might help others who didn’t know this fact.

Footnotes:

1

Well, maybe not. As Lee points out, you can find the information by looking at the undo node in the Elisp manual.

Posted in Programming | Tagged | 3 Comments

Second Year of Daily Posts

Posted on 2014-06-01 by jcs

Today is the second anniversary of daily posts on Irreal. For the past two years, Irreal has published at least one post a day.

Last year I remarked that it was a lot harder than one would think. Nothing that’s happened this year has given me any reason to change my mind on that. Some days I had absolutely no reserve posts and had to come up with something or break the chain. Fortunately, my muse always came through—even if at the last moment—and I was able to keep going.

I’m going to keep on keeping on so my hope is that on June 1st next year I’ll be able to celebrate three years of daily posts. So. Onward and upward.

Posted in Blogging | 1 Comment

Twenty Questions for Donald Knuth

Posted on 2014-05-31 by jcs

Over at Informit they’ve got a great Q&A with Donald Knuth. Twenty luminaries in computer science ask Knuth questions about himself, his work, and computer science. The questions are much more interesting than the usual session of this sort so it’s definitely worth taking a look.

Among the questioners are Jon Bentley, Radia Perlman, Robert Sedgewick, Silvio Levy, Al Aho, Guy Steele, Robert Tarjan, and Andrew Binstock, just to mention a few who are familiar to me. It’s no wonder the questions are of such high caliber.

If you read the entire article, you’ll learn lots of interesting things. For me, the most astounding thing was to learn (or more precisely, be reminded) that Knuth has been working on The Art of Computer Programming for more than 50 years. I’m pretty sure that that’s longer than most Irreal readers have been alive. As I say, astounding.

Posted in General | Leave a comment

org-ref

Posted on 2014-05-30 by jcs

I’ve written previously about John Kitchin and how he uses Emacs and Org mode for reproducible research. Kitchen is a researcher in Chemical Engineering from Carnegie Mellon University so he writes a lot of technical papers and he uses Org mode and Emacs to prepare them. You can watch the video that I linked above to get an idea of how he uses them to integrate his research notes and calculations into the source file for the paper.

If you’ve written or read any research papers from any scientific field, you know that they typically have citations to other papers and internal references to tables, figures, or other parts of the paper. Org can handle a lot of that—especially the internal links—out of the box and there are external packages to help with the bibtex tools.

Kitchin has written an Emacs package, org-ref, that integrates these functions in a consistent way. He describes the package in a blog post on his group’s site. If you write research or technical papers that have a lot of internal/external references you should take a look at the package to see if it can help you.

Kitchin says that the package currently works well only for LaTeX export but suggests that he will be adding support for other formats such as HTML in the future. Right now the package isn’t in ELPA and he doesn’t say whether he will place it there but it is available from his site: see his blog post for the link.

I hope he continues work on this package. It looks as if it could really make handling bibliographies a lot easier.

Update: Apparently, Kitchen is continuing work on org-ref. In a subsequent post he describes how to export to other formats and remarks that export to HTML is working pretty well now. If you’re interested in using Emacs to handle bibliographies, you should take a look at Kitchen’s blog. He has many posts describing the work he’s done in that area. It’s pretty impressive.

Posted in General | Tagged | 3 Comments

Calculating My Average Post Size

Posted on 2014-05-29 by jcs

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.

Posted in Programming | Tagged | Leave a comment