The Tao of Emacs

Let’s say, you wish to create a new script. In a shell-oriented system, you would begin with a command to start up an editor on that new file. However, since Emacs is already running, we just find-file the new script.²

Yes, not much different, but wait…

In order to test the script, we need to change the execute bit. In the Shell Way, one would exit the editor, an run the chmod command from the shell. In the Emacs Way, you either:

1. Type M-! and then the equivalent chmod command, or
2. Type M-x and then chmod, hit Return to select your file (as the current buffer is the default value), and then the permission’s value.

With the Emacs Way, one doesn’t exit the editor simply to change the value.³

Another subtle, but significant difference is how Emacs handles a REPL. For years, when talking to my C colleagues (and then my Java colleagues), a REPL seemed odd. However, dynamic languages for the JVM (like Scala, Groovy and Clojure) have made this less odd.

A REPL allows you to run an interpreter and give it commands and expressions to evaluate. For instance, with Ruby, you would run irb, and then type some expressions, like this:

$ irb
>> 5 + 6
=> 11
>> 1 + rand(6)
=> 3
>> 1 + rand(6)
=> 6
>> def die
>>    1 + rand(6)
>> end
=> nil
>> die
=> 3
>> die
=> 1
>> (1..3).collect { die }
=> [4, 3, 6]
>> (1..3).collect { die }.reduce(:+)
=> 10
>> def dice(num=2)
>>    (1..num).collect { die }.reduce(:+)
>> end
=> nil
>> dice
=> 6
>> dice
=> 11
>> dice(5)
=> 19

The output of every REPL for each language is different (and in this case, irb doesn’t color my input… that is just the side-effect of my export mechanism), but if you’ve never tried a REPL, this should give you a view.

This is a great way to import and investigate a new library or try out some experimental code. While the instant feedback is great, the actual user interface leaves a bit to be desired. Somes REPLs are nicer than others, for instance, bpython. is quite slick for a terminal-only application.

Emacs can give you the best of both a REPL and an editor.

Let’s walk through the above Ruby session, keeping in mind that one can often to have a similar approach in many other languages. Begin with: M-x and inf-ruby (I type ir and SMEX will auto-complete it).⁴

We can now type 5 + 6 and all the other expressions we did in the above REPL. Yeah, no big whoop here. Open another buffer (C-x b if you’re following along at home) called blah.rb, and type:

def die
  1 + rand(6)
end

With the cursor anywhere in there, issue M-x ruby-send-block (or C-c C-b) to send this function definition over to the REPL. Notice a bit of gibberish, but it will end with:

=> nil

Which is the results of evaluating a function definition in Ruby.

Pop into that original ruby buffer, and type die and return and you’ll be treated with random values from rolling our virtual die.

Better yet, back in your Ruby buffer, type die on a line by itself and hit C-x C-e (or M-x ruby-send-last-sexp), and the die function call is sent to the REPL and the results of the function is displayed.

The point of this exercise is that you can type some code and either select part of it or send a full block to the REPL to be evaluated.

Think about writing unit tests, and evaluating the expression to make sure it matches the assert as you go along. For this, I often use Magnar Sveen’s Expand Region project to easily select some section of code, evaluate it (that is C-c C-r), and expand the region even more to validate a larger section.

Let’s demonstrate with a slightly larger Ruby example. Add this to your blah.rb file:

def dice(num=2)
    (1..num).collect { die }.reduce(:+)
end

With your cursor anywhere inside the num=2, repeatedly hit the C-= key binding (whatever you have bound to the expand-region function) until everything inside the parenthesis is selected. Then C-c C-r to send that expression to the Ruby REPL. This assigns a global variable, num to 2, but that is fine for now.

Next, with your cursor on the opening paren in the expression: (1..num) hit C-= to select that expression, and again, C-c C-r to evaluate that expression. Yeah, it returns 1..2 which isn’t too exciting.

Hit C-= to add the .collect part to our highlighted region, and evaluate it with C-c C-r, and you should see [1, 2] in the REPL. Slightly more interesting.

If you hit C-= again, you’ll select the entire block, which is too much, as we just want to trailing block. Since our cursor is at the beginning, we hit C-x C-x to put the cursor at the end of the region, and C-8 C-f to move forward 8 characters to add the block, { die } to the region. Now evaluate that. We should get the results of rolling two die. Evaluate it again to get a different roll.

Hit C-e to add the reduce statement to the region, and evaluate that to get a number from 2 to 12. I’ve now validated to myself that my dice rolling function is good enough, but I wouldn’t be happy until I popped over to my test suite and started building a unit test in a similar way.