leah blogs: Emacs

Prelude and Motivation

After trying out and fiddling with a plethora of existing and self-written software to organize my notes, I have decided I need to stop experimentation and choose a solution that is sufficient, but most importantly, one that I actually will use and have migrated all my existing notes to. Note taking systems are not an end unto themselves.

Roughly speaking, my essential requirements are:

• Something that works with plain text, and ideally supports Markdown as that is the syntax I publish most things in and I am most familiar with.
• Something that can be used from Emacs, because that’s where I do most my text editing and writing.
• Something that stores a note per file. This has just proved to be the most future-proof way.
• Some basic means of connecting notes.

I found I don’t need these things:

• Support for direct HTML publishing, as I realized that most of my notes are written for myself and I’ll put them up somewhere else for publishing. (This usually involves prior editing anyway.)
• Having a fancy UI and graph displays. I consider these goodies I can easily go without.
• Specialized productivity features like to-do lists, date scheduling or time tracking. These are out of scope for my use: I use a regular calendar for things with a deadline (which I’m blessed to have very few of) and will stick to simple to-do lists for my personal projects.

Many people would recommend me org-mode now, but I’ve never been a fan of its clunky syntax and I really don’t need most of the features. org-roam at first looked promising but linking between notes is quite complicated and the database dependency seems to be overkill for a personal note taking system on modern hardware.

I decided to settle on howm, an Emacs mode that is not very well-known in the Western world but has gained a certain following in Japan.

It’s a roughly 20-year-old Emacs mode that’s still being used and maintained by its original author Kazuyuki Hiraoka, so I have confidence it will be around for some more time. You can format notes however you like, so I can use Markdown as I prefer. Notes are one file per note by default (but see below). It actually has features for date scheduling and to-do lists, but I won’t go deeper into them for now. Its code is reasonable simple and well structured, so I was able to extend it in a few ways easily, as I’ll detail at the end of this post.

What really sold me was this quote I found on the mailing list:

I cannot show a good general guide because I’m lazy, loose, and bad at tidying. I’ve already given up well-ordered notes. Howm may be suitable for those who are tired from strict systems.
— Kazuyuki Hiraoka

Such an undogmatic system is just right for my purposes.

How howm works

Since there are very few resources in English that explain howm (apart from this 2006 article that got lost in time), I shall give a quick introduction for the interested reader:

howm is short for “Hitori Otegaru Wiki Modoki”, which roughly translates to “Single-user Easy Wiki Mode”.

The basic feature set of howm is very simple, and can be condensed into the mantra “write fragmentarily and read collectively”. Essentially, howm provides an Emacs minor mode for marking text to trigger certain searches. Since it is a minor mode, you can use whatever major mode you like to use for your writing (e.g., I currently use markdown-mode).

Howm notes are kept in a directory hierarchy that you can organize how you wish; by default a date-based system is used and filenames include the current timestamp at creation. This provides unique and sensible note identifiers, so I stick to it. You also can create explicitly named note files, but I haven’t found a use for them yet.

There are two essential kinds of markup howm cares about: note titles and links. By default, titles are marked up by putting a ‘=’ at the beginning of the line, but this can be configured (and must be done so before loading howm-mode(!)). The benefit of adding a title to a note is that you can have the summary buffer show titles instead of matching lines, which can be helpful to get a better overview of search results. (The creator of howm is sceptical of titling all notes, I think it very much depends the average length of your notes. There is no requirement to use titles.)

There are two kinds of links supported by howm, namely goto and come-from (in a nod to INTERCAL). goto links are forward references and written like this:

>>> howm

Pressing return on this line when howm-mode is enabled will show a list of all occurences of the word howm in your notes directory.

In contrast, a come-from link is written like this:

<<< howm

And this will cause the word howm in any howm-mode buffer to be underlined and trigger a search where the buffer with <<< howm will appear first.

Thus, compared to most contemporary hypertext systems, we not only have a means of explicitly linking to other notes, but also for creating implicit contextual links—which can help you find connections between your notes that you didn’t see yet…

It is straightforward to implement something like #tags or WikiWords using these features, if you wish to do so.

Additionally, howm provides an inline link syntax [[...]] that works like >>> but can appear within a line. I make a suggestion below how to turn it into a direct link to the first page with the given title; but for now I decided not to use this very much.

The line-based nature of the >>> syntax prevents usage for “inline” links. After giving it some thought, I consider it a strength for a note-taking system to make forward links related to a paragraph and not part of a sentence. Additionally, it also makes the plain text easier to read as the link target is not interleaved into the text. (Compare with the use of reference-style links in Markdown.)

An aside: howm actually supports multiple notes per file by having multiple title lines in a file. The search summary will always show the title directly before the matching line. You can use C-c , C to create a new note in the current buffer. I don’t use this much, but I think it could be useful for glossary files that contain many short notes. Some people also use this for keeping multiple daily notes in a single file.

Using howm

Howm provides two main features to access notes: the menu and the summary buffer. The howm menu (shown with C-c , ,) provides a very customizable view into your howm notes. By default it shows your schedule, recent notes, and random notes. You can access many howm features with a single keypress from the menu. Since I don’t use the scheduling feature, I mostly access howm from the summary buffer instead.

The howm summary buffer shows the result of a search (C-c , g), a list of recent notes (C-c , l), or an overview of all notes (C-c , a). It is very convenient to see the matches and you get a preview of the note when you move the cursor to a search result. Typing RET will open the note for editing. Typing T will toggle between displaying matching lines or the titles of notes with matches.

In the summary buffer, you can also type @ and read all matching notes in a concatenated way, so you get the full context of all notes at once.

Setting up and customizing howm

Basic setup is reasonably well documented in English, but I’ll summarize it here. You can get howm from ELPA these days, so installing is very easy. You should set some variables to configure it according to your needs:

;; Directory configuration
(setq howm-home-directory "~/prj/howm/")
(setq howm-directory "~/prj/howm/")
(setq howm-keyword-file (expand-file-name ".howm-keys" howm-home-directory))
(setq howm-history-file (expand-file-name ".howm-history" howm-home-directory))
(setq howm-file-name-format "%Y/%m/%Y-%m-%d-%H%M%S.md")

Here, we decide that ~/prj/howm is the base directory for our howm notes, and we also put the two auxiliary files howm uses there. Additionally, we change the default name format to end with .md (which also turns on markdown-mode by default).

Next, we want to use ripgrep for searching howm. For my usage, plain GNU grep would be sufficient, but I want to use ripgrep in the next step too, so for consistency let’s use it for all searches:

;; Use ripgrep as grep
(setq howm-view-use-grep t)
(setq howm-view-grep-command "rg")
(setq howm-view-grep-option "-nH --no-heading --color never")
(setq howm-view-grep-extended-option nil)
(setq howm-view-grep-fixed-option "-F")
(setq howm-view-grep-expr-option nil)
(setq howm-view-grep-file-stdin-option nil)

The next addition is interactive search with ripgrep (C-c , r). This is the most useful feature I added to howm myself. I think it provides a great way to interact with your notes, as you get instant feedback from your search terms, and can stop searching as soon as you found what you were looking for. I used counsel-rg as an inspiration for this, and we turn the ripgrep matches into a regular howm summary buffer for further consumption.

;; counsel-rg for howm
(defun howm-list--counsel-rg (match)
  (if (string= match "")
  (howm-list-all)
(if (or (null ivy--old-cands)
	(equal ivy--old-cands '("No matches found")))
        (message "No match")
  (let ((howm-view-use-grep
	 #'(lambda (str file-list &optional fixed-p force-case-fold)
                 (mapcar
                  (lambda (cand)
		(if (string-match "\\`\\(.*\\):\\([0-9]+\\):\\(.*\\)\\'" cand)
                        (let ((file (match-string-no-properties 1 cand))
			  (line (match-string-no-properties 2 cand))
			  (match-line (match-string-no-properties 3 cand)))
                          (list (expand-file-name file howm-directory)
                                (string-to-number line)
                                match-line))))
                  ivy--old-cands))))
        (howm-search ivy--old-re t)
        (riffle-set-place
     (1+ (cl-position match ivy--old-cands :test 'string=)))))))

(defun howm-counsel-rg ()
  "Interactively grep for a string in your howm notes using rg."
  (interactive)
  (let ((default-directory howm-directory)
        (counsel-ag-base-command counsel-rg-base-command)
        (counsel-ag-command (counsel--format-ag-command "--glob=!*~" "%s")))
    (ivy-read "Search all (rg): "
	      #'counsel-ag-function
	      :dynamic-collection t
	      :keymap counsel-ag-map
	      :action #'howm-list--counsel-rg
	      :require-match t
	      :caller 'counsel-rg)))

(define-key global-map (concat howm-prefix "r") 'howm-counsel-rg))

Next, I tweak some sorting settings. I want the “recent” view to list files by mtime (so that recently edited files appear on top), but the “all” view should be sorted by creation date.

;; Default recent to sorting by mtime
(advice-add 'howm-list-recent :after #'howm-view-sort-by-mtime)
;; Default all to sorting by creation, newest first
(advice-add 'howm-list-all :after #'(lambda () (howm-view-sort-by-date t)))

A great usability enhancement is buffer renaming: since howm file names are a bit unwieldy (like ~/prj/howm/2022/03/2022-03-25-162227.md) you can use these two lines to rename note buffers according to their title, which makes switching between multiple notes more convenient.

;; Rename buffers to their title
(add-hook 'howm-mode-hook 'howm-mode-set-buffer-name)
(add-hook 'after-save-hook 'howm-mode-set-buffer-name)

Another personal preference is enabling orgalist-mode, which I like for shuffling around Markdown lists.

(add-hook 'howm-mode-hook 'orgalist-mode)

Finally we fix an anti-feature in howm: by default, it binds C-h to the same binding as backspace, but this is only useful on legacy terminals (and even then Emacs does the translation). I wouldn’t really mind, but it breaks the Emacs help feature, so we unbind C-h for the modes:

(define-key howm-menu-mode-map "\C-h" nil)
(define-key riffle-summary-mode-map "\C-h" nil)
(define-key howm-view-contents-mode-map "\C-h" nil)

My configuration ends with three definitions of action-lock, the howm mechanism for marking text active and do something on RET. Two of them are related to the reference management software Zotero, which I use for organizing papers, and enable me to link to articles in my Zotero database by URL or BibTeX identifier:

;; zotero://
(add-to-list 'action-lock-default-rules
             (list "\\<zotero://\\S +" (lambda (&optional dummy)
                                         (browse-url (match-string-no-properties 0)))))
;; @bibtex
(add-to-list 'action-lock-default-rules
             (list "\\s-\\(@\\([a-zA-Z0-9:-]+\\)\\)\\>"
                   (lambda (&optional dummy)
                     (browse-url (concat "zotero://select/items/bbt:"
                                         (match-string-no-properties 2))))
                   1))

Finally, as mentioned above, this is how to make [[...]] wiki-links directly point to the first page with that title, skipping the summary buffer:

;; make wiki-links jump to single title hit if possible
(add-to-list 'action-lock-default-rules
             (list howm-wiki-regexp
                   (lambda (&optional dummy)
                     (let ((s (match-string-no-properties howm-wiki-regexp-pos)))
                       ;; letting create-p be nil here, howm-keyword-search-subr
                       ;; should check create-p after open-unique-p
                       (howm-keyword-search (concat "= " s) nil t)))
                   howm-wiki-regexp-hilit-pos))

The whole configuration is part of my .emacs file.

Future ideas

One thing I want to implement but didn’t yet get around to is support for searching notes using ugrep, which has a nifty boolean search mode that applies to whole files, so you can do searches that are not limited to a line context (e.g. hoge|fuga -piyo finds all notes that mention hoge or fuga, but don’t contain piyo).

I may also look into the scheduling features of howm, but I direct you to the terse README for now, if you’re curious.

Anyway, I hope this was interesting and perhaps encourages you to look into howm, an Emacs mode that I feel doesn’t receive the attention it deserves.

NP: Bob Dylan—What Was It You Wanted

The major showstopper before I was seriously considering going to Git was the lack of an darcsum-like interface for Git.

Yesterday night I finally decided to write it.

git-status (included as git.el in the Git distribution) is usually good enough to use, but I often like to do partial commits, that is, commit only parts of a file. Git can do that now for some time, using git add --interactive or frontends like git-hunk-commit or git-wt-add. Still, there was no way to do it conveniently in Emacs.

Let me introduce gitsum:

You can freely delete hunks you don’t want to commit, split big changes, or even edit the patch directly if you feel adventurous. It also integrates into git-status so you can easily switch between these frontends.

Gitsum is hosted at http://github.com/chneukirchen/gitsum (which I highly recommend) and is mirrored at http://git.vuxu.org/, patches and additions are welcome! It’s still very fresh and has some rough corners, but I already notice my increase in productivity.

NP: Twelve Tone Failure—As I Hit the Floor

For some reason, almost everyone is hot about Ruby IDEs nowadays.

However, I still prefer using a “classic” editor, and I edit just about everything with it.

The editor is a lot like a handaxe. It’s an old tool, but it’s proven, and can be used in a lots of ways: hitting something, cutting meat, opening fruits. And, I can (and do!) use it to create other tools. It’s a sharp and powerful tool. Also, my handaxe is customized just how I like it. For example, if you are left-handed, your handaxe surely will look different than the handaxes of the others.

On the other hand, a modern IDE is a lot like a wrench. If you needed a wrench, you’d be happy to have one. Trying to turn a bolt with a handaxe will be difficult. But can your wrench drive nails? Maybe if you are good at it. Cut meat? Hardly.

You may now argue that this is a really bad comparison, and maybe you are right. But compare how the intelligent Stone Age man did all his day work with a hand axe, and how the experienced developer does everything with his editor: it’s not that far off. Do you know of a mechanic that only has a wrench?

I like my editor. It fits my needs perfectly, and I can customize everything how I need it.

NP: Tom Waits—Lucinda

Pastie is the new cool code pasting site around the net. Totally nifty; heck, you can even post to it with Vim.

Having nothing better to do (heh… you bet), I just couldn’t resist but get the good old elisp out and write a few Emacs functions to make it accessible from Emacs, too.

Well, there you are: pastie.el.

pastie.el defines three new functions you may want to bind to appropriate keys:

• pastie-region pastes the current region, shows the URL of the new paste and puts it in the kill buffer for immediate pasting.

• pastie-buffer pastes the whole buffer.

• pastie-get asks for a Pastie paste id and fetches it into an appropriate buffer.

Of course, all methods handle the various Pastie ways of syntax highlighting, provided you use the corresponding Emacs modes.

Happy pasting!

NP: Mark Knopfler—Everybody Pays

I worked over the weekend on various things. First, I fixed darcsum.el to strip/convert ANSI character sequeces, since several people complained. Thanks to Jose Antonio Ortega Ruiz and Matthieu Lemerre for reporting this. Please darcs pull to grab the latest changes.

Then, I spent some more time on Kashmir/Elusion and added a “Do What I Mean” mode. For example, instead of

^entries.each{
  ^recent?.true?{NEW}
  ^body
  ^time.with{^day/^month/^year}
}

You can now write (assuming you use Elusion):

^entries{
  ^recent?{NEW}
  ^body
  ^time{^day/^month/^year}
}

Elusion will then figure out on it’s own what you want to do (If there is an #each, iterate. If it’s true, just call the block. Else yield self to the block.) Also, you can now pass a block to Kashmir#expand to automatically create an Elusion.

Now, there is a restartable exception library to be coded…

NP: Bob Dylan—Knockin’ On Heaven’s Door

Since John Wiegley stopped using darcs, there have been no changes to darcsum.el, a fairly good Emacs-mode for interfacing with darcs.

With the update to darcs 1.0.2 darcsum.el even broke, as the look of the prompts darcs.el waits for has changed. Therefore, I have decided to “fork” it, fix it for 1.0.2 and add features I always wanted in darcsum.el.

You can get the latest darcsum.el by running:

darcs get http://chneukirchen.org/repos/darcsum/

Simply stuff the darcsum.el into your load-path and (require 'darcsum). Run it with M-x darcsum-whatsnew.

Features added by me include a Edit/Update-Log cycle (think of Arch) and having a look at the context of patches (think diff -u).

NP: Silbermond—1000 Fragen

I finally found out how to enter special characters the right way in Carbon Emacs. Previously, when I hit “ä” and the likes, it would tell me about “Undefined keys” and the like. Interestingly, the character C-q ä on my german keyboard creates a totally different character than it’s supposed to be (0x8a vs 0x8e4). I helped myself adding these characters with TextEdit afterwise, well knowing that this approach can’t be the whole truth.

However, this is now fixed. I simply added

(set-keyboard-coding-system 'mac-roman)

to my .emacs and now I can enter the correct characters with a single keypress.

I still haven’t found out how to make Emacs actually display these characters, though: I still only see empty boxes. Not that bad, but not perfect either. Comments on this would be very welcome.

Update 30jan2005: I fixed that issue! The code you need in your .emacs is:

(create-fontset-from-fontset-spec
 "-apple-monaco-medium-r-normal--9-*-*-*-*-*-fontset-mac,
  ascii:-apple-monaco-medium-r-normal--9-*-*-*-m-*-mac-roman,
  latin-iso8859-1:-apple-monaco-medium-r-normal--9-*-*-*-m-*-mac-roman,
  mule-unicode-0100-24ff:-apple-monaco-medium-r-normal--9-*-*-*-m-*-mac-roman")
(set-frame-font "fontset-mac" 'keep)
(add-to-list 'default-frame-alist
         '(font . "fontset-mac"))

NP: Interpol—Not Even Jail

I’ve been looking for an usable Outliner to run on Linux for a long time now. (My ideal is still UserLand Frontier’s.) And I’ve always been dissatisfied with the Emacs outline-mode because I think it doesn’t behave like an outliner should. It’s more for documents that have an outline.

However, isomer of #emacs just pointed out Org-mode, Carsten’s outline mode for keeping track of everything. I have to say it really rocks. You can manipulate the whole outline with a few keys, TAB, M-RET, M-left and M-right. Besides, it has lots of features like TODO lists, a diary view, calendar integration, hyperlinks, excellent table support (sweet), and HTML export. It also integrates with planner.el and remember.el.

Hmm, maybe I should add OPML support… :-)

NP: Eagles of Death Metal—Stuck in the Metal With You

Brad Parker did it: Emulating CADR microcode on modern hardware.

Who didn’t ever want to have a Lisp Machine of his own? There you go! :-)

Grab it over at www.heeltoe.com while it’s still hot! It already works fairly well, you can evaluate code and edit with Zmacs. However, there are some cons (pun intended): It takes 100% CPU even if idle and input is still fleaky (the mouse behaves really annoying…). Besides, it’s not exactly fast (recompiling with -mcpu helps a bit, though). It’s nothing that couldn’t be fixed at a later release.

One dumb thing is that the window is 768x1024, so you have to move the window all the time with a resolution lower than 1600x1200…

Quick screenshot:

NP: Bob Dylan—Shelter From The Storm

I’ve spent the whole afternoon writing two small scripts. What did I do?

My desktop is basically one Emacs instance beneath one Aterm. (Well, there’s a lot of stuff around it, but that doesn’t matter here.) When I code, I write the programs in Emacs, and run them in Aterm. Switching between those two windows is easy, I simply press M-Tab. This is a feature by Enlightenment. However, when my code raises an unhandled exception, there was no easy way to jump directly to the error; I had to jump to and retype the line number of the erroneous file.

This has changed now. I simply run my programs as usual, but write ete before:

$ ete ruby fuckup.rb
fuckup.rb:1: undefined method `fuckup' for main:Object (NoMethodError)

To handle this (trivial) error, I simply switch to Emacs and type C-x :. Emacs will now load the output of ete and jump to the first (mostly only) error. I could use C-x ` if I had several errors. (Unlikely with Ruby, but maybe a C extension…)

You can download ete here: ete (shell script), ete.el (elisp).

On a side note, put this into your .emacs:

;; Make ruby-mode usable for hs-minor-mode.
(add-to-list 'hs-special-modes-alist
         (list 'ruby-mode
           (concat ruby-block-beg-re "\|{")
           (concat ruby-block-end-re "\|}")
           "#"
           'ruby-forward-sexp nil))

Now open some lengthy Ruby file, and do:

M-x hs-minor-mode
M-x reveal-mode

Move over some defs, press C-c @ C-l (better rebind that :P), and be astonished moving your cursor in and out. ;-) Cool, eh?

NP: Velvet Revolver—Superhuman

Today I’ve spent some time to implement the counterpart of RigRag, a wiki-like hypertext system which I dub Scribble.

I decided to write it in Emacs Lisp, since I use Emacs for most of my other stuff too (I keep all my addresses in bbdb, for example), so that would be a nice fit.

I’d have liked to implement RigRag in elisp too, but it’s too graphical to be practical to be used inside a text editor (if you want to call Emacs that way :-)).

Well, I discovered that my elisp knowledge leaves a lot to be desired, so it’s probably going to take some time until I get into it again. However, I need to say that the Emacs documentation really is superb: Being clearly written, covering just about everything one needs to know, and having a comprehensive index is not something you see every day when working with software.

NP: Presidents of the USA—Last Girl On Earth

I finished nukumi.el today, which includes a major mode for writing nukumi blog entries. It works very nicely now as it

• highlights header lines,
• displays leading and trailing space,
• generates new blog entries with partly filled fields
  (that is, Date, Encoding, Now-Playing.)
• and calls nukumi on C-c C-c.

See it in action:

NP: Die toten Hosen—The Passenger

A great comment by Martin DeMello on ruby-talk, inside a long, unneeded thread on userface simplicity and commandlines:

vi isn’t easy to learn; it’s easy to use. You can do a lot of very powerful stuff with surprising ease, far more so than in the more userfriendly editors. emacs too, espcially if you’re an octopus :)

*rofl*

Yay, Dave Roberts cites me in his blog “Finding Lisp”; when he asked why so many Lisp projects use Arch:

The best thing I heard was from Christian Neukirchen who wrote and said it was “…because Lispers like to do it the Right Way.” Somehow, that sort of makes sense. Lispers certainly don’t follow the crowd. They look for good solutions to problems and they aren’t afraid to stick with something that isn’t winning the technology popularity contest. So, while the rest of the masses struggle on with CVS, it seems like a lot of Lispers are turning to Arch for its superior approach to change sets, branching and merging, etc.

I exchanged a few emails with Christian and as a result of his urging, I have started using Arch myself.

(I didn’t urge at all! I just told the truth :-))

So far, there were many Arch interfaces for Emacs, and a self-made repository browser contained the comment:

;; nbbba.el doesn't yet integrate with the other tla interfaces,
;; as time will tell which one of the few around will put through.

A mail from Matthieu Moy tells me:

That was true a few weeks ago, but today, tla.el and tilly.el (and recently mst-arch.el) joined xtla, which is now the Emacs interface for tla.

xtla calls itself “a very complete Emacs front-end for tla”.

I tried xtla before, and wasn’t too impressed of it, but a diff against a more recent revision tells me that lots of functionality was added. The archive browser feels a lot like mine but has lots of additional features like viewing changesets, diffing to arbitrary revisions etc. Furthermore, the code is a lot cleaner than mine, since it uses ewoc and not string twiddling for display.

Masatake Yamato even had a patch to make it use tree-widget to get a nice tree overview; he wanted to install that patch soon. It seems to kicks ass now.

Cory Doctorow does civil obedience in the cinema, and they like it!

Ihr seid alle Atheisten! Ich bin ein Christ, ich war von Anfang an Verlieren gewohnt!

NP: Hammerfall—Legacy of Kings

 <dan`b> hmm.  I think my lwn subscription runs
         out tomorerow
 <dan`b> "I believe ctrl-W for delete line
         originated, and is pretty much only used
 <dan`b> in vi and emacs (I have neither one
         installed on my system, and I'd
 <dan`b> rather not install something I'll
         only use once, so I can't confirm
 <dan`b> this)"

Ok, this LWN article really seems crap (haven't read it, don't have a subscription):

1. C-w doesn't delete the line in Emacs (that's what C-k does), but kills the region.
2. You have vi installed on your system.
3. If you're not interested in trying new things, you probably shouldn't write for "Linux Weekly News".
4. C-w works in lots of applications, it's supported in readline, Gtk+ and Mozilla has it too.

NP: Void Main—Follow the GNU feat. RMS

After installing texinfo 4.6, GNU Emacs 21.3.50.2 now runs out-of-the-box without any problems. I think it's time it replaces my current, rather old Emacs 21.1.

I also don't use CVS now to get the latest one, but GNU Arch, which simplifies getting diffs a lot.

Sag jetzt nicht das du müde bist. — Ich bin so fit wie ein Stein!

NP: Bob Dylan & Johnny Cash—I Threw It All Away

Just updated my GNU Emacs to CVS HEAD, trying to ride on the bleeding edge for a while...

Installation was quite painless, but my makeinfo was too old so I needed to hack the Makefiles a bit to include --force.

I tried the new GTK+ 2.0 support but didn't like it, the plain X style looks better on my box (but then, my GTK is quite old and I don't have anti-aliasing).

Also tried the new debugger mode—gdba—it works nicely but I personally don't use debuggers that often.

After removing the tons of new font-locking which seem to appear in every new version again, I like it better than my old 21.2 one. If I now knew how to make info-mode not remove the heading underlinings, it would be perfect.

Especially cool is the reveal-mode that shows the text inside the "..." of invisible regions if the point is over it. It makes exploring (and editing!) outline files a joy.

NP: Manowar—Hand Of Doom