One of the well known features of
Prelude is that it saves buffers
with changes in them automatically when you jump between
windows. This is achieved with several simple defadvices and without
going into many details the advice code for that feature might look like this:
;; automatically save buffers associated with files on buffer switch;; and on windows switch(defadviceswitch-to-buffer(beforeswitch-to-buffer-auto-saveactivate)(prelude-auto-save))(defadviceother-window(beforeother-window-auto-saveactivate)(prelude-auto-save))(defadvicewindmove-up(beforeother-window-auto-saveactivate)(prelude-auto-save))(defadvicewindmove-down(beforeother-window-auto-saveactivate)(prelude-auto-save))(defadvicewindmove-left(beforeother-window-auto-saveactivate)(prelude-auto-save))(defadvicewindmove-right(beforeother-window-auto-saveactivate)(prelude-auto-save))
Ouch - that a lot of redundant code! Luckily we can take care of the
redundancy by introducing a macro to generate multiple advices with
the same body:
(defmacroadvise-commands(advice-namecommands&restbody)"Apply advice named ADVICE-NAME to multiple COMMANDS.The body of the advice is in BODY."`(progn,@(mapcar(lambda(command)`(defadvice,command(before,(intern(concat(symbol-namecommand)"-"advice-name))activate),@body))commands)))
Looks a bit scary, doesn’t it? But it allows us to reduce the original code down to:
;; advise all window switching functions(advise-commands"auto-save"(switch-to-bufferother-windowwindmove-upwindmove-downwindmove-leftwindmove-right)(prelude-auto-save))
macroexpand can show us how the macro gets expanded:
Obviously if we want the macro to be truly universal we should factor
out the hardcoded before and activatedefadvice params, but
that’s beside the point. The point is that when you need to generate
some code Emacs Lisp’s macros have your back.
Almost every Emacs user knows that M-g M-g and M-g g (both bound to
go-to-line) will take him to the line of his choosing (provided he
knows the number of the target line, of course).
Surprisingly few Emacs users know that there is a similar way to jump
to a column by its number - M-g TAB (bound to
move-to-column). Interactively you cannot jump past the end of the
line you’re currently on, but you can always cook your own version of
the command to get around that limitation:
locate is one extremely popular Unix command that allows you to
search for files in a pre-built database.
One little know fact is that Emacs provides a wrapper around the
command you can invoke with M-x locate. You’ll be prompted to enter
a search string and you’ll be presented with a list of matching
filenames from locate’s database. Many of dired keybindings are
available in the results buffer (which will be using locate-mode major mode).
If you’d like you may change the command invoked by Emacs to supply the
results by altering the locate-command variable. Here’s how you can
start using OSX’s mdfind (the command-line interface to Spotlight)
instead of locate:
Obviously any command that takes a string argument and returns a list
of files would do here. In all likelihood you’ll never want to use
anything other than the default locate command, though.
Emacs’s Lisp interpreter is able to interpret two kinds of code:
humanly readable code (stored in files with .el extension) and
machine optimized code (called byte-compiled code), which is not
humanly readable. Byte-compiled code runs faster than humanly readable
code. Java or .NET developers should already be familiar with the
concept of byte-code, since it’s pretty central on those platforms.
You can transform humanly readable code into byte-compiled code by
running one of the compile commands such as byte-compile-file. The
resulting byte-code is stored into .elc files. One can also
byte-compile Emacs Lisp source files using Emacs in batch mode.
Here’s how you can compile everything in your .emacs.d folder:
Of course we can easily create an Emacs command that does the same thing:
(defunbyte-compile-init-dir()"Byte-compile all your dotfiles."(interactive)(byte-recompile-directoryuser-emacs-directory0))
user-emacs-directory is an Emacs variable that points to your init
dir (usually ~/.emacs.d on UNIX systems). This command will
recompile even files that were already compiled before (meaning a file
with the same name and the .elc extension instead of .el
existed). You can try the new command with M-x
You have to keep in mind that Emacs will load code from the .elc
files if present alongside the .el files, so you’ll have to take
steps to ensure you don’t have stale .elc files lying around. I’d
suggest the following solution:
(defunremove-elc-on-save()"If you're saving an elisp file, likely the .elc is no longer valid."(add-hook'after-save-hook(lambda()(if(file-exists-p(concatbuffer-file-name"c"))(delete-file(concatbuffer-file-name"c"))))nilt))(add-hook'emacs-lisp-mode-hook'remove-elc-on-save)
This code will make Emacs delete the some_file.elc file, every time the
some_file.el file in the same folder is saved.
A couple of closing notes:
If you don’t have any custom computationally
intensive defuns in your init directory - it probably doesn’t make sense
to byte-compile it.
Packages installed via package.el will be automatically byte-compiled during the installation process.
The code presented here is part of
Prelude. As a matter of fact
Prelude will byte-compile itself during the installation process (if
you used the installed script, that is). Prelude will also recompile
itself when M-x prelude-update is invoked.
Sometimes people tend to overlook how well Emacs and Emacs Lisp are
integrated. Basically there is no limit to the places where you can
evaluate a bit of Emacs Lisp and reap the associated benefits. From
time to time I find myself editing something and thinking - “Hey, it’d
be really great of I could just insert the result of some Emacs Lisp
expression at point!” (my thoughts are pretty crazy, right?). Here’s a
contrived example - I might have to enter somewhere the result of
1984 / 16. I can calculate that manually or I can fire up M-x calc
and get the result, or I can play extra smart and devise the following
command (which I did not actually devise - I’m pretty sure I saw it
in someone else’s config a while back):
(defuneval-and-replace()"Replace the preceding sexp with its value."(interactive)(backward-kill-sexp)(condition-casenil(prin1(eval(read(current-kill0)))(current-buffer))(error(message"Invalid expression")(insert(current-kill0)))))
Let’s bind that to C-c e:
Now in the buffer I’m currently editing I can type (/ 1984 16) and
press C-c e afterwards getting the result 124 replace the original
expression. Pretty neat!
I’ll leave it up to you to think of more creative applications of the command.
This command is part of
Every Emacs user knows that he can split the current window
horizontally (with C-x 2) and vertically (with C-x 3) as much as
he desires to. However, some Emacs users don’t know what to do with
the extra windows they’ve created when they do not them.
To delete the selected window, type C-x 0 (delete-window).
Once a window is deleted, the space that it occupied
is given to an adjacent window (but not the minibuffer window, even if
that is the active window at the time). Deleting the window has no effect on the
buffer it used to display; the buffer continues to exist, and you can
still switch to with C-x b or any other buffer navigation command.
C-x 4 0 (kill-buffer-and-window) is a stronger (and fairly
unknown) command; it kills the current buffer and then deletes the
selected window (basically it combines C-x k and C-x 0). Obviously
it’s a good idea to use it on windows displaying buffers you’re no
C-x 1 (delete-other-windows) deletes all the windows, except the
selected one; the selected window expands to use the whole frame.
(This command cannot be used while the minibuffer window is active;
attempting to do so signals an error.) In the era of narrow screens I
used that command fairly often when I needed to focus on a particular
task. Now I keep my screen split in half vertically 99% of the time,
but I still use C-x 1 from time to time when I’m about to resplit my
screen in some uncommon way.
Windows displaying help buffers (generally created with commands like
C-h ...) warrant a special mention. They can be deleted with a
single keystroke - q. That would delete the help window altogether
if it was created by the help command, or restore its original
content if the window existing beforehand and was reused by the help command.
This post continues a topic that was introduced in
smarter open-line few months
Often when editing code one wishes to open a line just above the
current one, which is properly indented relative to the existing code,
and position the cursor at its beginning. Such a feature is present
in most IDEs, such as IntelliJ IDEA, Eclipse and NetBeans. It’s
sometimes bound to Control+Shift+Enter. Last time I showed you how
to implement a similar function called smart-open-line, this time
will implement smart-open-line-above. Just add this snippet to your
.emacs (or .emacs.d/init.el or whatever):
(defunsmart-open-line-above()"Insert an empty line above the current line.Position the cursor at it's beginning, according to the current mode."(interactive)(move-beginning-of-linenil)(newline-and-indent)(forward-line-1)(indent-according-to-mode))(global-set-key[(controlshiftreturn)]'smart-open-line-above)
Evaluate the code (or restart Emacs) and you’ll be able to use
M-x smart-open-line-above or Control+Shift+Enter (aka C-S-return).
Admittedly this keybinding kind of sucks, so here’s another option for
you - M-o (used by default as the prefix for some font setting
commands nobody ever uses) for smart-open-line and M-O for
Most people that use Emacs are programmers - that’s a fact!
Most programmers have to deal with relational databases - that’s also a fact!
Programmers often interact with the database they have to use via some
dedicated client - be it a console or a GUI one. One fairly little
known fact about Emacs is that it features a mode that wraps around
terminal database clients, called SQLi. The mode allows you to
interact with a relational database from the comfort of Emacs. Sure,
you can run a terminal client like psql directly from ansi-term
(for instance) as well - but if you’re using a client with no
readline support (like the default clients for Oracle and DB2)
you’ll certainly appreciate SQLi.
Let’s play a bit with SQLi. To create a PostgreSQL connection start
by running M-x sql-postgres. You’ll be prompted for username, database,
password and host and then you’ll be dropped in a buffer dedicated to the
connection you’ve specified. Apart from being able to run all sorts of
SQL in that buffer you’ll also be able to send to it SQL from .sql
files you’re editing in Emacs.
Let’s see how you can do that in a bit more detail. First you have to
associated an SQL file with a connection. While in some .sql file
execute M-x sql-set-product and type postgres. Afterwards do M-x
sql-set-sqli-buffer and select the name of the connection buffer you
want to use (it’s probably called *SQL* if you have only one
connection buffer). Now you’ll be able to use commands like
sql-send-region (C-c C-r) from the .sql buffer and the code from
the region will be executed in the associated connection buffer.
Have a look at the documentation of sql-mode for further details.
When writing code from time to time we have to write comments as
well. Most of the time programmers are using single-line comments,
denoted by some special starting character(s), like #, //,
etc. When you want to write a few lines of comments in Emacs you have two
Write the first line of the comment.
Go to the next line.
Insert the comment delimiter.
Continue writing the comment.
Option B (editor’s choice)
White the first line of the comment.
Press M-j (indent-new-comment-line).
Continue writing the comment on the second line.
The command breaks the line at point and indents the following line,
continuing the comment if invoked within one. The indentation on the
second line matches the indentation on the first line.
# first line# indented line|(we press `M-j` here)# |(we get here after pressing `M-j`)
This command is intended for styles where you write a comment per
line, starting a new comment (and terminating it if necessary) on each
line. If you want to continue one comment of the type /* */ across
several lines, use C-j (newline-and-indent).
Outside of comments M-j behaves pretty much the same way as C-j.
When you’re writing code you usually have to take into account the
programming language’s convention for maximum line length. Most
programming languages urge hackers to keep line length under 80
characters(although in recent years it has often been argued that such
rules should be relaxed to 100-120 characters, given the state of
current computer displays).
There are many ways to highlight lines that exceed a certain length in
Emacs, but I find one to be particularly elegant - the use of the
built-in whitespace-mode. Most people use whitespace-mode to
visualize spaces, tabs and trailing whitespace, but it can actually do
a bit more that that. Here’s the magic config:
(require'whitespace)(setqwhitespace-line-column80);; limit line length(setqwhitespace-style'(facelines-tail))(add-hook'prog-mode-hook'whitespace-mode)
The above snippet will enable whitespace-mode only in major modes
for programming. If you want to enable whitespace-mode everywhere
you might want to do this instead:
whitespace-line-count determines that maximum line length; feel free
to set this to whatever value suits you. whitespace-style determines
what kind of stuff whitespace-mode is going to highlight. At this
example we want to highlight only the part of lines exceeding the line
length limit. Take a look at whitespace-style’s documentation for
more details(C-h v RET whitespace-style).
Here’s the result:
It will probably come as no surprise that this functionality is
enabled out-of-the-box in Prelude.