jumping back to past locations

With the pop-global-mark-command, you can quickly jump back to the locations you were before, like tracking back your bread crumbs.

A typical example of this is when doing some programming and looking up some function in another file, which refers to a function in yet another file, and so on – for example, see navigating through source code using tags.

Press C-x C-SPC (the default key binding for pop-global-mark) to make your journey back to where you came from; it works in a cyclical fashion as well, so you can go on and on.

Quite useful – you may want to use a more convenient key binding though. Admittedly, it's hard to come up with any intuitive keybinding which is not already taken by something else…

setting fonts

NOTE: if you like Org-Mode, please go and vote for it in SourceForge Community Choice Award – it's in the Most Likely to Change Change the Way You Do Everything-category.

---

For pleasant working with emacs, one of the more important things is choosing the right font ('face'). Especially within a windowing system, and especially with Emacs 23, there are a lot of possibilities. I am thinking from the Linux/X-Window perspective here – the support for anti-aliased fonts makes things look so much nicer – as discussed before.

On X, there are different ways to set your font. One way is through the menu (Options/Set default font.../). We can also set it in our .emacs, with (set-default-font "<font>"), or using ~/.Xdefaults. The latter method makes emacs-startup quite a bit faster, but this may have become less important in the age of emacs –daemon (Emacs 23).

barb wire

In either case – .emacs or .Xdefaults – you must provide some string describing the font. Up to Emacs-23, under X you had to use the 'barb wire'-style X font description, which you could get from a tool like UI-designers' dream xfontsel; the font description would then look something like:

  -*-bitstream vera sans mono-medium-r-*-*-*-120-*-*-*-*-iso8859-*

emacs 23

In the brave new world of Emacs 23, on X, you can also use the somewhat clearer Fontname-<size> format. You can get a list of the fonts installed on your system with the fc-list commond; if you only want to get the monospaced fonts, use

 $ fc-list :spacing=mono

For details, see the FontConfig user manual.

Note that installing fonts under X is rather easy as well these days; in most cases all you need to do is put the .ttf-files in your ~/.fonts directory and all will be find, although some program might require a restart.

Once you have chosen a font, you can put it in your ~/.Xdefaults:

Emacs.font: Envy Code R-10

and don't forget to run xrdb ~/.Xdefaults afterwards, to tell X about the changes. All of this should happen before you start emacs.

Alternatively, you can put in your .emacs something like:

(if (eq system-type 'windows-nt)
  (set-default-font "-outline-Consolas-normal-r-normal-normal-14-97-96-96-c-*-iso8859-1"))

(if (eq window-system 'x)
  (set-default-font "Inconsolata-11"))

This will set a different default font, based on whether you are running on Windows or X. You can freely adapt it to your own desires of course.

Side note: if there is yellow in the code snippet above, that is because of hightlighting lines that are too long.

face value

There are many fonts; which one is the 'best' for you, obviously depends on personal taste and also what you want to with it. As I use emacs for coding but also for reading e-mails and writing documents, there are some things that are important for me:

• monospace
• most important: clear and crisp, even when using smaller font sizes;
• clearly separate O (capital O) and 0 (zero);
• support italic display;
• support the characters I might use (incl. accented characters and some greek ones).

Following these rules, I found the Envy Code R font to work very nicely. It's not fully Free though: Free to use but distribution prohibited. Raph Levien's Inconsolata is nice as well and truly Free; it does not provide an italic font though (at least it does not show in Emacs). Here's a list of programming fonts.

more

Hmmm… I wanted to write some small entry… And there is so much more to say about fonts. As often, EmacsWiki has a lot of information; for example about FontSets, which allow you to use a sort-of combination-font, which is nice if you have to work with mixed character sets (Latin, Arabic, CJK etc.).

Also, the emacs-fu entry on zooming in/out is useful in this context, even though Emacs 23 has gained something similar by default.

Also, the entry on color theming may be interesting, in this entry we only look at the default font, but you can change fonts governing only part of emacs as well; see M-x list-faces-display.

Or get information about the font at point with C-u C-x =.

search and replace in files

I always try to do more things from within emacs; as said before, it's all about return on investment for all the time spent mastering emacs. One of the things I sometimes still used a separate terminal for, was search and replace of text in files – a quick grep or sed from the command line.

source code: tags

If you're searching (not replacing) symbols in source code, the most convenient way is to use a tagfile. A while ago, I discussed navigating through source code using tags (using GNU Global). I still often see people writing code in emacs, and then opening a terminal open to grep for function names, definition and so on… There is really no need for that; see the linked entry.

The GNU Global tagfile system unfortunately does not have a search-and-replace function; if you are using etags, however, you can use M-x tags-query-replace to replace the symbols in all files in the tagfile.

GNU Global users can of course still use the other search-and-replace mechanisms below.

other files: rgrep

For searching recursively for some strings (regexps) in a file tree, there is the very useful M-x rgrep. It will ask what you want to search for, some pattern for the files to match, and the top of the directory to search.

So, for example, if you want to find all occurences of the string 'FIXME' in txt-files in your ~/Documents directory tree, you would do something like:

M-x rgrep
FIXME
*.txt
~/Documents

and you will get at buffer with all matches. For this, it uses the same kind of buffer you use for compilation, and you can jump to the matching locations just like you can jump to error locations in the compilation output - that is why with M-x next-error you can jump from match to match, even though of course they are not really errors. The default shortcut for next-error is C-x`, but you can of course remap that to something saner, exempli gratia:

(global-set-key (kbd "<M-prior>") 'previous-error) 
(global-set-key (kbd "<M-next>")  'next-error)

so you can use M- with PgUp/PgDown to jump through the matches (or errors).

One final comment about rgrep: in the above example, the FIXME is a regular expression (as discussed in building regular expressions, while the *.txt is a shell pattern (see e.g. the findutils manual).

replacing: dired

If you want to replace text in multiple files, your best bet is to use dired, the emacs file manager.

dired deserves its own entry (and probably more than one), but if we just look at search-replace, the steps are not too hard. Suppose we want to replace all strings FOO with BAR in a bunch of files in ~/myfiles/. We open dired with C-x d, enter ~/myfiles, and a list of the files in that directory appears.

Now, we mark the files we'd like to change by moving the cursor to them and press m (unmark with u). You can also mark filenames matching some regexp with M-x dired-mark-files-regexp (or '* %', obviously) or files containing some regexp with M-x dired-mark-files-containing-regexp (or '* g').

After marking some files, you can use M-x dired-do-query-replace-regexp to interactively replace some regular expression in all of them – you have to press 'y' to confirm the changes. You can quit this process by pressing 'q'.

dired can even work recursively, as an anonymous commenter remarked (thanks!); slightly edited: You can type 'i' to insert a subdirectory to the dired buffer. You can also run M-x find-name-dired or M-x find-dired to generate a dired buffer with the results of the find-command. Then you can mark wanted files and perform query replace with 'Q'. Also see: Emacs Nerdery: Search & replace across files.

As an alternative, you can use an external package like FindR for recursive search & replace. I haven't used that one myself though, as I haven't had the need yet.

emacs-fu feed updated

At one point in your life, you reach the conclusion that you are not perfect. Even I did :-). For example, some of the Emacs-Fu posts contain errors (typos, out-of-context copy-past etc.), which are usually quickly found by some attentive reader. I do attempt to test things of course, but sometimes things slip through.

Of course, I can quickly fix those mistakes; I do know how to use a text editor after all. The trouble with that is that it provokes aggregators like Planet Emacsen and others to consider this as a new post, which is shown as such on the main page. Of course I don't want to spam the poor Planet Emacsen readers with updates just because I fixed a typo in some old entry.

The problem is not with those aggregators – it's with blogger.com, which does not invoke the right formula to say that something is updated instead of published. And my power to change blogger.com is rather limited.

Blogger does support tag-specific feeds though; so, my workaround is the following:

• The feed with all new posts: http://emacs-fu.blogspot.com/feeds/posts/default/-/new
• A feed with all updates (this is the current one): http://emacs-fu.blogspot.com/atom.xml

When I update an entry, I will remove the new-tag, so aggregators that use the first feed will not be bombarded with these small changes - and I am planning a few..

So, if you only want to get the new posts, I'd recommend changing to the first feed. Planet Emacsen has already done so (thanks Edward!).

Now keeping my fingers crossed it'll all work as expected...

ERC: the emacs IRC client

ERC: IRC with emacs

I am migrating more and more of my computer tasks to emacs; I already discussed Twitter and e-mail (with Wanderlust); I'm also using emacs-w3m for some of my web browsing (more about that some other time).

Reason for this ongoing emacsication is to get some return on investment for those countless hours spent on mastering the One True Editor. And it pays off - I can manipulate and glue all these programs together so they fit my workflow like a glove.

Recently, I have also started use emacs for IRC, another great Finnish invention. I am not really an IRC power-user, but I do use; before, I used irssi for that, in a ansi-term console (as explained). But now I have switched to ERC, the emacs IRC-client. You can do just about anything with ERC – I have only barely scratched the surface. But let me share my basic setup.

There first step is getting ERC; it's bundled with any recent emacs, so all you need to do is to add it to your .emacs:

(require 'erc)

That was not too hard, was it?

Now, the thing this is to determine what irc-servers / channels you'd like to join (of course you can do that later manually, but automate what we can). So, we define erc-autojoin-channels-alist:

;; joining && autojoing

;; make sure to use wildcards for e.g. freenode as the actual server
;; name can be be a bit different, which would screw up autoconnect
(erc-autojoin-mode t)
(setq erc-autojoin-channels-alist
  '((".*\\.freenode.net" "#emacs" "#gnu" "#gcc" "#modest" "#maemo")
     (".*\\.gimp.org" "#unix" "#gtk+")))

So, the first element is the IRC-server (with appropriate wildcards), the other elements are channels. This will make ERC automatically join the channels when it notices you're connected to the IRC-server.

And read the comment – it took me some time to figure out why things weren't working. Also, you might want to change these IRC-channels to your own favorites.

The next thing is tracking: ERC can track the various channels you're in, and notify you when there is something new in the channel (it will colorize the channelname in your modeline). This is generally useful, but I don't really care about when people join or leave, or other IRC-meta spam. So:

;; check channels
(erc-track-mode t)
(setq erc-track-exclude-types '("JOIN" "NICK" "PART" "QUIT" "MODE"

                                 "324" "329" "332" "333" "353" "477"))
;; don't show any of this
(setq erc-hide-list '("JOIN" "PART" "QUIT" "NICK"))

Note, the last line has nothing to do with this tracking, that's just telling ERC that I am not interested in those things at all, so it should hide them.

Almost there. Now, I have some function to actually start ERC; it's based on some code in found somewhere, but cannot find right now. The function will start ERC, or switch to it if it's already running – it will actually switch to the most recently active ERC-buffer, which makes things a bit easier to manage.

(defun djcb-erc-start-or-switch ()
  "Connect to ERC, or switch to last active buffer"
  (interactive)
  (if (get-buffer "irc.freenode.net:6667") ;; ERC already active?

    (erc-track-switch-buffer 1) ;; yes: switch to last active
    (when (y-or-n-p "Start ERC? ") ;; no: maybe start ERC
      (erc :server "irc.freenode.net" :port 6667 :nick "foo" :full-name "bar")
      (erc :server "irc.gimp.org" :port 6667 :nick "foo" :full-name "bar"))))

Note: don't forget to replace the :server-value as well as foo and bar with your own preferences. It should be clear what they mean…

You can bind this function to some easy key, and things get really convenient; for example:

;; switch to ERC with Ctrl+c e
(global-set-key (kbd "C-c e") 'djcb-erc-start-or-switch) ;; ERC

Once you have started ERC and are connected to some channels, things work pretty much as in any IRC-client. For each channel, a buffer is opened, and from their on it is up to you to have enlightening conversations with other people around the globe…

Once more, I have only barely scratched the surface of ERC. These are just some basic instructions for getting things working. After that, there are a million things you can do; EmacsWiki has an extensive section on it, with more information and customization then you'll probably ever need.

e-mail with wanderlust

e-mail with wanderlust

(This is part I of entry on the wanderlust e-mail client; part II will appear soon).

Earlier, I have written about how I am using mutt as my e-mailclient. I discussed running mutt inside emacs as well. Of course, mutt is an external program, which puts some limits on its integration with emacs. I did try various emacs-based clients, such as VM (ViewMail) and GNUS, but they always left me a bit unsatisfied.

To start with, it was rather hard to set these programs up – and I am an Emacs-user, I like tweaking things… Still, it was hard to get even simple things working. Maybe I have uncommon wishes, but my desired setup already sent me to the edges of the googleable universe.

But now I have found an emacs-based client that seems to work really well for me. It's called Wanderlust, and it's a fine piece of Japanese engineering. It can be a little bit intimidating to set up at first, even though I found it still much easier than the other emacs-based clients I tried. Anyway, I am sharing a very basic setup here, enough to get you going.

What about my setup? Well: I use maildirs – that is, I download my mail into a local ~/Maildir directory-tree, either with e.g. fetchmail or with offlineimap. It's a particulary nice setup for offline-usage: whenever there's a network connection, I suck up all the mails and have them available offline. I work like this since the days when there was only expensive dial-up access to the net, and later I found it very convenient when I was traveling with a laptop and had only occasional net-access.

So, Maildir access is pretty important for me, and I'll describe my setup for using Wanderlust with it here. If you're using IMAP instead of Maildirs, you might be interested in the Emacs with Wanderlust and GMail-article.

Getting started

So, how to get started with Wanderlust?

In short: install Wanderlust and put some stuff in two files (~/.wl and ~/.folders).

A little bit longer:

• get wanderlist - I am using the wl-beta packages from Ubuntu/Debian, which makes this a painless process, but you can also use source packages;
• put your Wanderlust-configuration in a special file: ~/.wl;
• put a list of the mail folders you're interested in, in a file called

~/.folders. (yes, you can customize all this)

For the rest of the discussion, let's assume we have a Maildir which contains some folders:

• inbox for incoming e-mail
• bulk for incoming Mailing List mail
• drafts for drafts
• sent for sent e-mail
• trash for junk email

All incoming mail is going to either inbox or bulk. I'm not going to discuss how to get the mails there – I assume you're already have these thing set up; otherwise, you can take a look at tools like fetchmail, retchmail, procmail and friends. Note that much of the discussion here applies as well if you're using Wanderlust with POP or IMAP.

What to put in ~/.wl?

So, how to setup Wanderlust to use this? Well, our configuration goes into a file called ~/.wl. There's a million more things you can set up here , but let's stick to the basics here. I'll discuss more tricks and extensions later.

;; mode:-*-emacs-lisp-*-
;; wanderlust 
(setq 
  elmo-maildir-folder-path "~/Maildir"          ;; where i store my mail

  wl-stay-folder-window t                       ;; show the folder pane (left)
  wl-folder-window-width 25                     ;; toggle on/off with 'i'
  
  wl-smtp-posting-server "localhost"            ;; put the smtp server here
  wl-local-domain "myhost.example.com"          ;; put something here...
  wl-message-id-domain "myhost.example.com"     ;; ...

  wl-from "Me <me@example.com>"                  ;; my From:

  ;; note: all below are dirs (Maildirs) under elmo-maildir-folder-path 
  ;; the '.'-prefix is for marking them as maildirs
  wl-fcc ".sent"                       ;; sent msgs go to the "sent"-folder
  wl-fcc-force-as-read t               ;; mark sent messages as read 
  wl-default-folder ".inbox"           ;; my main inbox 
  wl-draft-folder ".drafts"            ;; store drafts in 'postponed'
  wl-trash-folder ".trash"             ;; put trash in 'trash'
  wl-spam-folder ".trash"              ;; ...spam as well
  wl-queue-folder ".queue"             ;; we don't use this

  ;; check this folder periodically, and update modeline
  wl-biff-check-folder-list '(".todo") ;; check every 180 seconds
                                       ;; (default: wl-biff-check-interval)

  ;; hide many fields from message buffers
  wl-message-ignored-field-list '("^.*:")
  wl-message-visible-field-list
  '("^\\(To\\|Cc\\):"
    "^Subject:"
    "^\\(From\\|Reply-To\\):"
    "^Organization:"
    "^Message-Id:"
    "^\\(Posted\\|Date\\):"
    )
  wl-message-sort-field-list
  '("^From"
    "^Organization:"
    "^X-Attribution:"
     "^Subject"
     "^Date"
     "^To"
     "^Cc"))

What to put in ~/.folders?

So, that was the basic setup. Now we need to tell wanderlust about the folders we'd like to see in the user-interface: ~/.folders. Wanderlust does not automatically use all the folder in your ~/Maildir. The folder names in ~/.folders can refer to maildirs, newsgroups, POP-account, IMAP-folders and a couple of other ones. In particular, you can combine folders to show as aggregate folders in Wanderlust.

Wanderlust distinguishes the kind of folder something is by looking at a special prefix character. For maildirs, this is a dot ('.'), IMAP-folders get a '+', newsgroups get a '-' and so on. After the mailbox name, you can have a 'friendly name' in quotes, which is what will show up in the user-interface.

Something like this:

# WL folders (put the '#' always at the beginning of the line)
.inbox     "Inbox"
.bulk      "Mailinglists"
.drafts    "Drafts"
.sent      "Sent Mail"
.trash     "Junk"

Note, the little format has some more tricks; e.g., if you had some folders, you cold have something like:

# WL folders (put the '#' always at the beginning of the line)

# 'Lists' will be a tree node with three elements
Lists {
        .mailinglist1 "A mailinglist"
        .mailinglist2 "Another Mailinglist" 
        .mailinglist3 "Yet one more mailinglist"
}

# you make virtual folders from combined lists with the '*'
AllMyMailingLists  *.mailinglist1,.mailinglist2,.mailinglist3

Anyway, there's plenty of room for experimentation here…

Now, we're ready! Start Wanderlust with M-x wl. You will be greeted, and things are relatively easy from there on. You might want to use the menu at first at least, as the default keybindings are somewhat surprising (like a for reply, and w to compose a new message).

What's next?

As I said, there are 10E6 things to configure and to customize, but this should give you a reasonable setup to start with; you might want to change some details (like the folder names) to match your situation. Good luck!

As a true emacs-mailer, Wanderlust nicely integrates with e.g. BBDB (the addressbook) and org-mode. You can also use GPG (through mailcrypt), spamfiltering, and so on. I will discuss some of those things in the second part of the discussion of Wanderlust.

tetris

The game of Tetris has turned 25 24. I don't care very much about computer games, but I've nevertheless spent quite a bit of time playing Tetris - its brilliance is in its simplicity.

Obviously, emacs comes with a Tetris-clone; just type M-x tetris RET and there you go! There is very little useful things to customize about the game, except maybe you'd like to keep your ~/ clean and set:

(setq tetris-score-file 
  "~/.emacs.d/tetris-scores")

I'd also like to point to the lisp source code, which is only 658 lines long - almost CodeGolf-worthy. It's an interesting read if you are that kind of person. To see the source code, access the help for M-x tetris, i.e., press C-h f tetris and Enter (as discussed in Helpful Emacs). You'll get a help buffer then, which includes a link to tetris.el, the source code; obviously, you need to have the sources installed. In Ubuntu/Debian, you can install the source code through the emacs22-el or emacs-snapshot-el packages, depending on the version of emacs you're using.

Thanks to emacs, you can actually read the source code in one buffer, while playing tetris in the other one!