The single most useful Emacs feature

Auto-complete words in your code based on what already exists in the buffers:

M-/

Keep hitting M-/ until you find the word you are looking for.

Cuts down tremendously on how much you type.

A not so well known feature that I find very useful is M-x align-regexp. If you mark a region and execute it, you will be asked for a regular expression, and emacs will then line up the first match of that expression on every line, by padding with spaces (or tabs, if you like). For example, say that you have a list of variables in your code:

int a = 2;
int a_longer_variable_name = 73;
int i = 0;

Then you can mark those lines and to M-x align-regexp and specify = as the expression, and it will align it like:

int a                      = 2;
int a_longer_variable_name = 73;
int i                      = 0;

Maybe not the most important feature in the world, but I use it regularly, and it sometimes impresses non-emacs people. :)

M-x occur

This feature is very useful when re-factoring/analyzing code. It's one of the things that keeps me from becoming a Vim user.

Anything

Anything! It's a kind of Quicksilver / Launchy / slickedit / Ubiquity tool inside Emacs.

Out of the box it allows you to type a word or regex and presents you lists of matching:

• buffers (defaulting to the previous buffer, allowing you to switch back & forth between two buffers)
• files from the current directory
• recent files
• emacs functions / commands
• info pages
• man pages

And it's easily extensible, you can easily add Google suggestions, or grep / find / mdfind tools (most of them being allready there).

With Anything, I don't need iswitchb anymore, and I rarely use (ido-)find-file, since most of the time the files I want to open are already in the recent files list or the current directory list.

It changed the way I use Emacs!

Org Mode

Org Mode for project planning. From the home page:

Org-mode is a mode for keeping notes, maintaining ToDo lists, and doing project planning with a fast and effective plain-text system.

It comes with Emacs, and it has a great integrated, plain text, programmer friendly, builtin table & spreadsheet engine! (Includig auto re-aligning and formulas.)

Smart Tab

Smart Tab makes your tab key smart. If you're at the end of a symbol it tries to complete it, otherwise it indents the current line / region.

It works great for me: it makes line indenting, region indenting and completion available near the home line.

Don't forget about a little known command C-x M-c M-butterfly

self-insert, by far, imo.

Keyboard macros are very powerful when dealing with list of stuff...I use them as often as possible.

Here's the rundown of my F-keys:

F1: Gnus. Takes some learning, but cut my daily email time down to 20 minutes.

F2: ansi-term. Fairly full featured terminal emulator with a mode where you can switch back into behaving like an emacs buffer for kill/yank/macro goodness.

F3: slime. Crazy good tool for hacking the good hack with Common Lisp.

F4: switch-to-buffer "scratch". The scratch buffer is a good place to do fancy Emacs stuff when you don't want to type in the mini-buffer (try C-j).

F5: compile. You don't realize how great this is until you also grok next-error and previous-error.

F6: visits the buffer I have usually associated with an SQL session, either in an ansi-term or using psql.

F7: w3m. Very slick, fast web browser. Perfect for searching documentation.

F9: Visit my todo file in org-mode. org-mode, like gnus, takes a while to learn, but you can go so damn fast with it, it's worth it.

F10: calendar. Not as nice as org-mode but I haven't switched over all the way yet.

F11: open the EMMS playlist. EMMS doesn't come with the usual upstream Emacs distribution, but it's a pretty reasonable OGG/MP3/etc player.

F12: I run ERC and bitlbee. F12 brings me to the chat buffer with all my contacts from Google Talk and AIM in it.

Insanely cool thing not on one of my F-keys: TRAMP. TRAMP integrates into the way emacs finds, reads, and writes files. You can use file names like /sudo::/etc/passwd to edit things as root without starting another emacs, or /ssh:jfm3@jfm3.org:foo/bar.html to edit files remotely without staring a remote emacs.

Generalized ompletion modes and facilities are useful too. I like completion.el, but there are several to choose from.

Definitely check out www.emacswiki.org. Tons of good ideas there. Good luck!

string-rectangle (C-x r t) and kill-rectangle (C-x r k). They allow to add stuff in front of every line in a block of text or---vice-versa---remove such stuff.

Elisp. While the language itself can be a little bit clunky (for a lisp) it is so nice to be able to extend or fix your editor on the fly when you need to do so.

Flyspell-mode! "Flyspell enables on-the-fly spell checking in Emacs by the means of a minor mode."

Can be configured to check LaTeX documents and comments in some other languages (flyspell-prog-mode).

dired (M-x dired) let me navigate folders by touch-typing, much faster than browsing in a GUI.

yasnippets

Textmate-like snippet expansion functionality for Emacs.

I'm not sure if iswitchb is little known but it's something I use countless times everyday. It makes switching buffer that little bit easier. When you enter C-x b to switch buffers iswitchb allows you just to enter a unique substring of the buffer name to select it which can often just be a single character. It's hard to explain but easy to try and once you've tried it you'll never switch it off.

partial-completion-mode does something similar in that it can autocomplete any minibuffer commands. It works best if it give it a hint by typing any dashes in the commands. For example, for M-x yank-rectangle I can use M-x y-r [tab] and have it autocomplete.

And there's TRAMP for opening files on remote machines, usually via SSH. It works a treat on Windows using plink.exe from the Putty package.

Most of us are familiar with M-! for running a quick shell command from inside Emacs. A somewhat lesser known facet of this function involves using a prefix command of 1:

M-1 M-!

This runs the shell command and inserts the output at point in my buffer.

But what good is that? It lets me insert text into buffers, but not interact with it in any significant way. What I really need is a way to get the shell to take input from my buffer. Enter the cousins M-| and M-1 M-|. From the docs:

M-| runs the command shell-command-on-region, which is an interactive compiled Lisp function in `simple.el'

M-1 M-| runs a shell command on the region and replaces the region with the output of the command.

In general, I prefer to use features built into Emacs, but when there's no Elisp equivalent available, I can carry out text transformations I need simply and easily:

M-1 M-| perl -p -e 'y/a-zA-Z/n-za-mN-ZA-M/'

To rot-13 encrypt a region quickly, for instance.

(Incidentally, The keystrokes C-1 through C-0 and M-1 through M-0 are the same (by default) as C-u 1 through C-u 0, which makes it very easy to type in repeat arguments. Just hold down M and type in 1 and |, or hold down C and type in 7 and n.)

I like interactive SQL mode to give me command line editing and history while using sqlplus.

M-x sql-oracle

And I add the following to my .emacs file:

(defun my-sql-interactive-mode-hook ()
  (setq tab-width 8))
(add-hook 'sql-interactive-mode-hook 'my-sql-interactive-mode-hook)
(require 'sql)

Now I can start a sqlplus session and I get C-up and C-down to navigate through prior sql commands (similar to shell mode). This requires sqlplus to be available.

M-x re-builder

Interactive regular expression builder that shows you live in the current buffer just what the regular expression is matching. Great for working out what things might need to be escaped (e.g. () pairs) and whether there's hidden tabs in the whitespace.

When you're done you just cut-n-paste into M-x query-replace-regexp or similar.

How about the newbie-friendly

C-h k

which shows the documentation for the command associated with any key.

Or

C-h f

which shows the documentation for any particular command, given its name (i.e. what you would type after M-x).

I find these to be very helpful while learning emacs.

hippie-expand, best text expansion in emacs, binding it to TAB and it will always do the right thing (and also very customizable).

Though it's not an emacs feature, it's always worthwhile to point out to any newbies to remap their caps lock keys to control. Save those pinkies!

Using ido for finding symbols in the current buffer: http://www.emacswiki.org/cgi-bin/wiki/ImenuMode

Speeding up navigation by adding shortcuts to jump 5 lines per keystroke:

;; Faster point movement
(global-set-key "\M-\C-p" 
  '(lambda () (interactive) (previous-line 5)))

(global-set-key "\M-\C-n" 
  '(lambda () (interactive) (next-line 5)))

But the single biggest productivity booster for me has been swapping numbers and punctuation when programming in C++: http://infolab.stanford.edu/~manku/dotemacs.html

Pretty hard to limit myself to the single most useful feature, but I like this command that hasn't been mentioned yet: auto-revert-tail-mode.

Open up a log file you’d like to monitor in emacs and then do M-x auto-revert-tail-mode. Emacs will automatically watch the file, just like POSIX tail -f.

M-x rgrep

I've bound it to F4, I'm using it all the time to interactively greping for file in a recursive manner. Combine that with easy bindings for next-error (F9), previous-error (shift-F9) and you have struck gold!

It always makes my co-workers impressed how quickly I can find things. No tags needed and it's /very/ fast.

Someone else mentioned keyboard macros, but provided a broken link.

That feature may seem inane if you've used it with other platforms. But keyboard macros in Emacs are far more powerful, or at least easy to access the power of, than any other system I have used.

You can start simply by typing "C-x (", then anything you do is recorded to be played back... which means searches, replacement, opening new files, and so on. Then when you are done you can type "C-x )" to end the macro, and C-x e to replay the last keyboard macro. If you want to execute a macro multiple times, you can do so by pressing "e" repeatedly after the first execution via "C-x e". You can also run name-last-kbd-macro to name it, then use insert-kbd-macro to save off the macro you just defined somewhere (like .emacs).

The real power of macros comes into play when you use multiple cut buffers (registers), to save away various fragments of text in the middle of a macro and re-use the parts elsewhere. You can for example have a macro that expects some key text to be in register A for insertion, perhaps a search term in register B, and some other text to append elsewhere in register C grabbed on the fly within the macro. Or of course use multiple registers like multiple clipboards, all within emacs - the key bindings are different than they once were, but the commands you want are copy-to-register and insert-register.

All that, and it's basically as simple as typing something once (carefully) and then having Emacs repeat what you were doing with very complex changes possible.

I have used the combination of keyboard macros and registers to do things as diverse as turn lines of words into multiple lines of code appropriate for the word on the line, repair damaged LDIF files from an LDAP system, or do various refactoring tasks.

Org-mode. My whole life is in a massive, single .org file.

Compiling from within emacs, and then for each error, being able to visit the line of code causing the error with a keystroke.

Bookmarks. Emacs bookmarks are both named and persistent, two features that many editors fail to offer.

They are invaluable because not only can I save my place in a file, I can also bookmark a directory that will be opened with Dired. I use them to jump to my most visited locations on the file system, and my main Org Mode files. Having a bookmark which effortlessly takes me where I want to go prevents me from losing my focus while I click around in the Finder or Windows Explorer.

I manage large numbers of bookmarks by namespacing them - all of my Org file bookmarks start with 'org' for example. This makes it easier to find a bookmark with tab-completion.

How to use them:

• C-x r m BOOKMARK <RET> Set the bookmark named BOOKMARK at point (`bookmark-set').

• C-x r b BOOKMARK <RET> Jump to the bookmark named BOOKMARK (`bookmark-jump').

• C-x r l List all bookmarks (`list-bookmarks').

I'm still waiting for Visual Studio to introduce named bookmarks - you need to install ReSharper just to get numbered ones!

M-x gdb to test in the debugger while automatically moving through the source tree in other windows. Set break points by opening the source file and doing C-x on the appropriate source lines.

M-x shell to directly access the shell from emacs. When used with a split screen (C-x 3), it becomes very quick and easy to do things. No need to continually switch between programs.

Most-used and most-useful features (for me):

• navigational keyboard bindings (M-b, M-f, C-a, C-e, etc) work well for fancy keyboard layouts. You do not use Home, End, PgUp, PgDn, arrows, therefore there is no need to relearn touch-typing when, for example, on notebook these keys are placed in unusual places.

• It works in console (emacs -nw) as well as with GUI. And it works under Windows, Linux, Mac. You can use the same editor both in command-line and GUI environment on any OS.

• It has server-mode which allows an instant opening of new documents in the same editor environment.

• It allows to view several documents (and/or different parts of the same document) simultaneously. It is especially useful for wide-screen monitors.

• Embedded command-line (M-!).

• version-control (C-x v v - do the next logical version control operation on the current file.)

• find, open, switch, create file, buffer (C-x C-f, C-x b) via ido.el