emacs-fu

It's sometimes nice to see the changes you've made to a file. If the file is under version control, you can use the 'diff'-features of the version control system of course; or you can use diff-buffer-with-file to compare your buffer with the version on disk. That obviously only. works when you haven't saved the file yet.

Anyway, a bit easier, straighforward way may be to use highlight-changes-mode. With that mode, emacs can give a special color to parts of the text that you have changed.

;; higlight changes in documents
(global-highlight-changes-mode t)
(setq highlight-changes-visibility-initial-state nil); initially hide

The last line tells me that the changes should not be visible unless I want to see them.

I defined a key binding (F6) so I can easily toggle between visible/invisible changes:

;; toggle visibility
(global-set-key (kbd "<f6>") 'highlight-changes-visible-mode) ;; changes
;; remove the change-highlight in region
(global-set-key (kbd "S-<f6>") 'highlight-changes-remove-highlight)

With this last keybinding S-<f6> (Shift-F6), I can remove the change-indication of the current region (selection). Here are some other useful keybindings to quickly jump between various changes:

;; alt-pgup/pgdown jump to the previous/next change
;; if you're not already using it for something else...
(global-set-key (kbd "<M-prior>") 'highlight-changes-next-change)
(global-set-key (kbd "<M-next>") 'highlight-changes-previous-change)

Another interesting thing you can do is M-x highlight-compare-with-file.

The only remaining problem with highlight-changes-mode is that the default colors are, well, hideous. But of course, that can easily be fixed by changing the faces:

(set-face-foreground 'highlight-changes nil)
(set-face-background 'highlight-changes "#382f2f")
(set-face-foreground 'highlight-changes-delete nil)
(set-face-background 'highlight-changes-delete "#916868")

Or adding to your color-scheme:

(highlight-changes ((t (:foreground nil :background "#382f2f"))))
(highlight-changes-delete ((t (:foreground nil :background "#916868")))) 

Now, with these color changes, the foreground stays the same, only the background changes a bit. I am using a dark theme, you might want to change the colors to fit in with your theme.

There are some more features - for example, to rotate through changes of different age. For such things I prefer to use a version control system, but you might want to check it out.

Tracking changes can be quite useful. And, unlike some word-processing software, emacs does not hide your highly embarrassing modifications somewhere in your document…

I can write headings by starting lines with some stars, the number of stars determining the heading level:

* level 1 heading
 some text
** level 2 heading
 some more text
*** level 3 heading
 even more

org-mode helpfully gives them some different colors; by pressing TAB when I am on a heading, I can hide/show the lower levels and the contents. Nice!

It's also easy to get all the basic markup by decorating your words a bit:

This is *bold* /italics/ _underline_ [[http:/emacs-fu.blogspot.com][Emacs-Fu]]

In org-mode it looks like:

This is *bold* /italics/ _underline_ Emacs-Fu

There are many more things; for example, there's the table editor; I simply type |country|capital|<Enter>|-<Tab> and I get:

| country | capital |
|---------+---------|
| | |

Now, I fill in the names in the colums, ending each line with <Alt><Enter> (or M-RET), and org-mode takes care of making everything fit, so we get:

| country | capital |
|-------------+-----------|
| finland | helsinki |
| netherlands | amsterdam |

You can even insert formulae in the cells, turning this into a simple kind of spreadsheet. Haven't used that yet though.

Now, one of the things I use org-mode for is blogging; for that, I need to convert the org-text into HTML; this is simple org-export-as-html (or C-c C-e). I can then copy the HTML into blogger.com or whatever (that might be automatable). You can also export to plain-text, LaTex and other formats.

I found that it makes me a much more productive blogger if can use org-mode; it's so much more convenient to write the mark-up than to write raw HTML. Now, sometimes I might want still want to write some raw HTML, but that can be easily done:

#+BEGIN_HTML
 <button onclick="alert('you are!');">I feel lucky!</button> 
#+END_HTML

in the export HTML this will become: I feel lucky! How cool is that?!

However, I only found out about the nicest trick very recently from the org-mailing list.

In this blog, I often use blurbs of code; I'd like to show those blurbs with the syntax-highlighting that emacs gives me. For that, I use the htmlize-package. For example, when showing some Emacs-Lisp code, I would copy that to an Emacs-Lisp buffer, then run htmlize-region on the code, and finally copy the result back in a raw-html block (like the one for the <button>).

I wondered - could I not do that automatically? I could mark code in org-mode as being 'Emacs-Lisp'-code (or Perl, or Python, or …), and when I'd export the html, org-mode would go through the trouble of calling htmlize-region on it and use that in its output. Sounded like a nice idea, I asked for some advise on how to do it.

Five minutes after asking, I got a reply – 'just use #+BEGIN_SRC/#+END_SRC'. Wow – it was already there in org-mode, it's even documented, but somehow I missed that. So, now I can write:

#+BEGIN_SRC perl
 for (my $i = 0; $i != 10; ++i) {
 print "hello, world!\n";
 }
#+END_SRC

#+BEGIN_SRC c++
 for (int i = 0; i != 10; ++i)
 std::cout << "hello, world!" << std::endl;
#+END_SRC

and in the export HTML, this will look like:

for (my $i = 0; $i != 10; ++i) {
 print "hello, world!\n";
}

for (int i = 0; i != 10; ++i)
 std::cout << "hello, world!" << std::endl;

I am impressed.

These were just some of the things I've discovered in the last few months of using org-mode, and I am only scratching the surface. Feel free to share your org-mode-writing tips in the comments :-)

To make things even more interesting, in different contexts, different rules apply. The above is all about regexps in strings in Emacs-Lisp. However, things are different when you provide a string interactively.

Suppose you search through your buffer (with M-x isearch-forward-regexp or C-M-s). Now, your input is not interpreted by the Lisp interpreter (after all, it's just user input). So, you're exempt from the slash tax, and you can use \bcat\b to match, well, \bcat\b.

So, regexps can be hard, and Emacs-Lisp makes it somewhat harder. A natural way to come up with the regular expression you need, is to use trial-and-error, and this is exactly what isearch-forward-regexp and friends do. But what about the slash-taxed regexps that you need in your Lisp code?

The answer is M-x re-builder. I am sure many people are already using it, but even if there were only one person that finds out about this through this blog-post, it'd be worth it! And this is the whole trick here: whenever you need a regexp in your code, put the kind of string it should match in a buffer, and enter M-x re-builder.

re-builder will put some quotes in the minibuffer. You type your regexp there, and it will show the matches in the buffer as you type. It even supports different regex-syntaxes. By default, re-builder will help you with the strings-in-Emacs-lisp kind of regexps; this is called the read-syntax. But you can switch to the user-input regexps with C-c TAB string RET (yes, these are called string here). There are some other possible syntaxes as well.

One final trick for re-builder is the subexpression mode, that you activate with C-c C-e (and leave with q). You can than see what subexpressions match (ie. if we can match cat, cut, cot etc., with \\bc\\(.\\)t\\b, and the subexpression would then contain the middle letter. re-builder automatically converts between the syntaxes it supports, so you could use 'string-mode' as well, bc\(.\)t\b.

The first great new trick mentioned in the dot-emacs trickery-post was savehist-mode (thanks Valvo).

With savehist-mode, you can save your minibuffer history (ie. the commands you gave). It's the simple alternative to more complex session-saving mechanisms like desktop-save-mode and (many!) friends.

save-hist-mode lets you can customize quite a few things, so my setup now looks like this:

(setq savehist-additional-variables ;; also save...
 '(search-ring regexp-search-ring) ;; ... my search entries
 savehist-file "~/.emacs.d/savehist") ;; keep my home clean
(savehist-mode t) ;; do customization before activate

The savehist-additional-variables customization particularly interesting; you can put any (printable) variable in the list, ie. you could put kill-ring in there, to retrieve your old kill ring (the clipboard) when you restart emacs again.

Note: if you want emacs to remember your recently-used files between sessions, you can take a look at recentf.

Also, note that I am setting savehist-file to ~/.emacs.d/savehist. In general, I'll try to put all my emacs files there, instead of in my home-directory. This makes it a bit easier to back up things and keep my ~/ clean. For historical reasons, I still have my ~/.emacs, but I could use ~/.emacs.d/init.el instead (great tip by Steve Purcell).