Shortly after feeling at home in Emacs, I started hacking in Emacs Lisp to get a feeling for it. Compared to other editors, it felt very natural and easy to extend it. The process is rather simple:

1. Create a new EmacsLisp Buffer / File
2. Write some EmacsLisp Code
3. Select the code and evaluate it
4. Now you can use the feature

You don't even have to save the code in order to use it.

The following line of code binds the shortcut ctrl-x + 8 to a function that inserts the string "test" at the current cursor position

(global-set-key (kbd "C-x 8") (lambda () (interactive) (insert "test")))

In order to use it, you don't have to save or start anything, simply type it, and at the end hit ctrl-x ctrl-e. After that, the command has been registered and you can use it anywhere.

Lets say you're editing a DNA code file, and in there you have to repeat a certain set of characters n times, i.e. gatacagatacagataca.... So you'd like a function that you can hand the characters as well as how often you want them repeated⁴. The required code for that is quite simple:

(defun repeat-the-chars (chars repeat)
  (interactive "MEnter Characters: \nnEnter Repetitions: ")
  (mapcar (lambda (x) (insert chars)) (number-sequence 0 repeat)))

(global-set-key (kbd "C-x 8") 'repeat-the-chars)

• The line (interactive "MEnter ...) is an interactive format string. It tells Emacs to read user input when calling the function. First, it will ask for a String (M is the input format code for a string), then it will ask for a Number (n is the input format code for a number). These two values will then be added as function arguments (chars and repeat).
• The line (mapcar ...) runs a anonymous function / lambda over the number range from 0 until repeat. Each function invocation uses the insert call to insert text.
• Finally, the global-set-key line tells Emacs to run the function repeat-the-chars when using the ctrl-x + 8 shortcut. The quote (') in front of the function name keep Emacs from executing it right away. It is a bit like a function pointer. It quotes the symbol instead of evaluating it right away.

I find this impressively easy. This allows me to quickly write short functions for complex tasks whenever I deem it necessary. I recently had to write Scala code to define models for the Slick framework. The models had a lot of fields, but the definitions all looked rather similar. The syntax was as follows:

def name = column[String] ("bo_name")
def location = column[String] ("bo_location")
def opens = column[Int] ("bo_opens")
def closes = column[Int] ("bo_closes")

Since I had to write a lot of fields in this a syntax, I sought a way to automate it. I wrote the following Emacs Lisp Snippet:

(defun create-column (name type)
  (interactive "Mname: \nMtype: ")
  (setq tp (split-string name "_"))
  (insert (format "  def %s = column[%s] (\"%s\")\n"
		  (last tp) type name)))
(global-set-key (kbd "C-x 1") 'repeat-the-chars)

• setq defines a local variable 'tp' that contains a list split by "_". So when I enter "bo_test" it would contain ("bo", "test")
• (last tp) gets the last element from the list tp. The rest should be self explanatory

After this, I could just hit ctrl-x + 1, Enter the type and name of the field, and it would output a field definition as above⁵.

After these simple explorations of why Emacs Lisp is nice, lets have a look at something more elaborate. But first, a sidenote about calling functions.

As you have seen above, whenever I wrote a new function, I bound it to a keyboard shortcut, like ctrl-x + 8. This has several disadvantages though:

• You never now which keyboard shortcuts are really free, as different major and minor Emacs modes (i.e. modes for different languages or editing extensions) may also set a shortcut for the key that you chose.
• If you have too many functions, there're no keys left or it will be confusing to remember which key did what.

Fortunately the default setup of Emacs has a fantastic alternative to setting keyboard shortcuts, the M-x shortcut to run commands by name. After typing the shortcut, you can simply enter the name of the function that you're searching for and the function will be executed. Even better, Emacs has integrated auto completion for this, so if you happen to not remember the detailed name of the function anymore - no problem. Even better, there're Emacs plugins that offer fuzzy searching for this, so instead of entering repeat-the-chars you simply enter repeat char and the correct function will be highlighted.

This is a great way to call any function that you defined previously, or any function that was delivered with Emacs or with one of the plugins that you installed. I can't stress how awesome this is. Imagine you're searching for a function to truncate lines in Emacs. Just hit M-x type "truncate" and toggle-truncate-lines will appear in the search results. It is like QuickSilver, Butler, Spotlight or Alfred for all the functions in your editor.

Now that we've seen the basics of Emacs Lisp functions, let's try our hands on something more difficult. One of the advantages⁶ of Emacs is that it offers so much functionality in various disciplines that it can almost be seen as an operating system. There's a newsgroup reader, a webbrowser, a terminal, a mail reader, a calendar, a todo framework, a flowchart and UML mode, a RSS reader, a couple of games, and much more. As explained above, all these modes offer functions that you can call from your Emacs Lisp code. This makes it terribly easy to hack together a complex mode to achieve several things at once⁷.

Now we need a problem to solve. Consider you're working at the hottest new startup and you're about to launch. Your boss comes over to explain a problem that just rose up. You need to send out the press release to a ton of tech websites, but there's no money left to buy a bulk mailing software, and there's also no time left to cobble something together in PHP and MySQL (or Python or Ruby), and now the whole startup is damned just because they can't get the press release out.

You look at him with with a soft expression of understanding, unfold your fingers and answer "I'll have that running in Emacs in 15 minutes", enjoying the puzzled look in his eyes as he remembers how he and the other Textmate users always made fun of you and your very weird editor and how you're still living in the 80ties⁸. So now there's our problem, and we need to solve it quickly lest the others will start ridiculing Emacs again.

First, we'll need to set up Emacs to send mail. Thankfully, that's easy and already documented elsewhere.

The first 3 minutes are over, but now your Emacs can send mails just fine using the compose-mail function.