Emacs Redux

Return to the Essence of Text Editing

A Peek at Emacs 24.4: Superword-mode

| Comments

In a previous post I wrote about camel-case aware editing with subword-mode. Emacs 24.4 adds a complementary minor mode called superword-mode, which also alters the behavior of word-based commands when enabled.

Normally Emacs would consider underscores and dashes word separators (snake_case and lisp-case anyone?). This affects all word commands - forward-word, backward-word, kill-word, etc. Let’s see a couple of examples (| denotes the cursor position):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
;; word with dash
|some-word

;; press M-f (forward-word) once
some|-word

;; press M-f again
some-word|

;; press M-b (backward-word) once
some-|word

;; word with underscore
|some_word

;; press M-f once
some|_word

;; press M-f again
some_word|

;; press M-b once
some_|word

;; word in camelCase (assuming subword-mode is not enabled)
|someWord

;; press M-f once
someWord|

;; word in camelCase (assuming subword-mode is enabled)
|someWord

;; press M-f once
some|Word

Personally I find the default behavior combined with subword-mode great. I do a lot of Ruby and Lisp programming and it also makes a lot of sense to me to be able to navigate the portions of a complex word, but I guess not everyone feels this way. Enter superword-mode - when it’s enabled all “complex/compound” words are treated as a single word:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
;; word with dash
|some-word

;; press M-f once
some-word|

;; word with underscore
|some_word

;; press M-f once
some_word|

;; word in camelCase
|someWord

;; press M-f once
someWord|

Note that you cannot have subword-mode and superword-mode enabled at the same time. Turning one of them on will disable the other.

Personally, I don’t see much value in superword-mode as a mode that’s enabled all the time, but I can imagine some useful scenarios in which I’d enable it briefly to do some focused editing.

A Peek at Emacs 24.4: Prettify-symbols-mode

| Comments

Emacs 24.4 ships with a new minor mode called prettify-symbols-mode. Its purpose is to replace the standard text representation of various identifiers/symbols with a (arguably) more aesthetically pleasing representation (often a single unicode character would replace several ascii characters).

A classic example would be lambda from various Lisp dialects that many people prefer to replace with the greek letter λ (small lambda). prettify-symbols-mode allows you to achieve this by relying on a simple mapping expressed in the form of an alist that each major mode must initialize (prettify-symbols-alist). Simply put - major modes have to provide the configuration for prettify-symbols-mode.

Lisp modes do this via lisp--prettify-symbols-alist:

1
2
(defconst lisp--prettify-symbols-alist
  '(("lambda"  . ?λ)))

This means that out of the box only lambda will get replaced. You can, of course, add more mappings for different major modes:

1
2
3
(add-hook 'emacs-lisp-mode-hook
            (lambda ()
              (push '(">=" . ?) prettify-symbols-alist)))

Let’s see the mode in action. Consider this bit of Emacs Lisp code:

1
2
3
4
(lambda (x y)
  (if (>= x y)
      (something)
      (something-else)))

After you do M-x prettify-symbols-mode you’ll end up with:

1
2
3
4
(λ (x y)
  (if ( x y)
      (something)
    (something-else)))

To enable this for a particular mode use (add-hook 'some-mode-hook 'prettify-symbols-mode). If you’d like to enable it globally just add the following to your config:

1
(global-prettify-symbols-mode +1)

By the way, sky is the limit for symbol prettification. One fairly extreme example would be vim’s plugin haskell-conceal+ that goes to great lengths to bring proper mathematical notation to Haskell code. We can achieve more or less the same effect with prettify-symbols-mode, but one have to ask themselves where should we draw the border between tasteful and distasteful prettifications.

Configure the Scratch Buffer’s Mode

| Comments

Pretty much every Emacs user knows of the *scratch* buffer - after all it’s always present when you start your Emacs. If you’ve set inhibit-startup-screen to t (which I recommend) it will even be the very first buffer see each time you fire up your beloved editor (unless you alter initial-buffer-choice, that is).

The scratch buffer was conceived a scratchpad for notes and Emacs Lisp experiments and a lot of Emacs users find it quite handy. On the other hand - even more users don’t really write Emacs Lisp and probably find little value in this buffer.

One little know fact about the *scratch* buffer is that its initial major mode (by default it’s lisp-interaction-mode) is not hardcoded and you can alter it. If you’re a Ruby developer you might opt to make it use ruby-mode by default:

1
(setq initial-major-mode 'ruby-mode)

If you do this I’d also advise you to change the buffer’s initial contents. By default they are:

1
2
3
;; This buffer is for notes you don't want to save, and for Lisp evaluation.
;; If you want to create a file, visit that file with C-x C-f,
;; then enter the text in that file's own buffer.

For Ruby something like this might be better:

1
2
3
4
(setq initial-scratch-message "\
# This buffer is for notes you don't want to save, and for Ruby code.
# If you want to create a file, visit that file with C-x C-f,
# then enter the text in that file's own buffer.")

Or you can simply set initial-scratch-message to nil and be done with it.

Travel Back and Forward in Git History

| Comments

I recently discovered an extremely cool package called git-timemachine that allows you to step though the git history of the file you’re currently editing in Emacs.

Using it is pretty simple:

  • visit a git-controlled file and issue M-x git-timemachine (or bind it to a keybinding of your choice)
  • use the following keys to navigate historic version of the file:
    • p visit previous historic version
    • n visit next historic version
    • w copy the hash of the current historic version
    • q exit the time machine buffer

Here you can see git-timemachine in action:

P.S.

This package is bundled with Prelude.

Become an Emacs Redux Patron

| Comments

Securing funding for OS projects and blogs (outside of displaying annoying ads) is a hard endeavor. While I’d love to raise enough cash to work on CIDER, projectile and Emacs itself for an entire year through some wildly successful crowdfunding campaign, that’s unlikely to ever happen.

That said, I recently discovered an interesting alternative to one-off crowdfunding campaigns called gittip. Self-described as sustainable crowdfunding (meaning people will get microdonations (say half a buck) from their patrons each week) it seems like a reasonable way to raise a modest sum of money so you could work on open-source projects more than your regular schedule might permit.

So, if you like Emacs Redux and the Emacs projects in which I’m involved like:

  • Prelude - An Emacs distribution built on top of GNU Emacs 24
  • Projectile - Project Interaction Library for Emacs, that stays out of your way
  • clojure-mode - A major mode for programming in Clojure
  • cider - A Clojure programming environment for Emacs
  • guru-mode - An annoying companion on your journey to Emacs mastery
  • rubocop-emacs - Emacs integration for RuboCop
  • zenburn-emacs - The Zenburn color theme, ported to Emacs
  • solarized-emacs - The Solarized color theme, ported to Emacs
  • puppet-mode - A mode for editing Puppet 3 manifests
  • swift-mode - A mode for editing Swift code

consider supporting my work via gittip.

Support via Gittip

P.S.

Alternatively you can use PayPal.

Paypal

New Emacs Blogs

| Comments

The problem with Emacs blogs is one can never have enough of them (especially the good ones).

I’d like to draw my readers attention to two new blogs:

lunarsite

lunarsite is not exactly new (it was started in March 2014), but I don’t think enough people have come across it, so I’m mentioning it here anyway. It’s operated by one of the most prolific members of the Emacs community in recent years - the great Sebastian Wiesner (of flycheck and cask fame).

If you’re thinking of writing your first major mode - you’ll find some great advice there.

Endless Parentheses

Endless Parentheses is a brand new blog started by Arthur Malabarba. It’s dedicated to concise posts on improving your Emacs productivity.

The content so far is similar to the articles I write here, so if you like Emacs Redux you’ll likely enjoy Endless Parentheses as well.

Quickly Find Emacs Lisp Sources

| Comments

One thing Emacs users deal all the time is looking for the source of various libraries and function or variable definitions. Typically this involves the use of commands like C-h f (describe-function), C-h v (describe-variable) and C-h k (describe-key) and jumping to the source from the help buffer those commands produce. Let’s see if we can improve upon this workflow.

find-func

Enter the built-in Emacs library find-func. It provides a myriad of useful commands to help us quickly locate sources. Let’s take a brief look at some of them.

  • You can find the source of a library with M-x find-library. If you want to find the source of ido you can do so like this:
1
M-x find-library RET ido RET

I’d suggest binding the command to C-h C-l for quick access:

1
(define-key 'help-command (kbd "C-l") 'find-library)
  • You can find the source of a function definition with M-x find-function. Here’s an example:
1
M-x find-function RET find-function RET

I’d suggest binding the command to C-h C-f for quick access:

1
(define-key 'help-command (kbd "C-f") 'find-function)

We can actually do one better - we can directly jump to a command definition using a keybinding of the command with M-x find-function-on-key. Here’s how we can find the source the command bound to C-a (beginning-of-line):

1
M-x find-function-on-key RET C-a

I’d suggest binding the command to C-h C-k for quick access:

1
(define-key 'help-command (kbd "C-k") 'find-function-on-key)
  • You can find the source of a variable definition with M-x find-variable. Here’s an example:
1
M-x find-variable RET large-file-warning-threshold RET

I’d suggest binding the command to C-h C-v for quick access:

1
(define-key 'help-command (kbd "C-v") 'find-variable)

The library provides other useful commands as well - like find-function-at-point and find-variable-at-point.

If you don’t like the keybindings I suggested you can use find-function-setup-keys instead. This will give you keybindings like C-x F, C-x V, C-f K (plus a few extra for commands like find-funtion-other-window).

elisp-slime-nav

Another really cool way to browse Elisp sources (and documentation) is the third-party package elisp-slime-nav. Assuming you’ve installed it already you can enabled it like this:

1
2
3
(require 'elisp-slime-nav)
(dolist (hook '(emacs-lisp-mode-hook ielm-mode-hook))
(add-hook hook 'elisp-slime-nav-mode))

Once this is done you’ll be able to jump to the source of the Emacs Lisp object at point (function or variable) with M-. (as in SLIME and CIDER for Common Lisp and Clojure respectively) and jump back with M-,. You can also see the description of the object at point using C-c C-d (or C-c C-d d).

That’s all for today, folks!

P.S.

All the suggested keybindings are present out-of-the-box in Prelude. elisp-slime-nav is also enabled out-of-the box in Prelude.

MELPA Stable

| Comments

We all know and love the MELPA package repository. At least we all know it, but not everyone loves the idea of using package snapshots. Some people would rather use only stable package releases and that’s understandable. Unfortunately the major community repository for stable packages Marmalade is often plagued by technical issues (that should be fixed once its elnode-powered rewrite is ready) and stale packages (due to the fact the sometimes people upload packages they don’t own there and stop updating them after a while).

Now there’s an alternative to Marmalade, which offers a MELPA-like experience - MELPA stable. It offers stable packages built automatically from git tags, meaning the only thing you have to do to release a new version of a package (assuming there’s a MELPA recipe for it, of course) is to tag the release in git. No more stale packages! No more manual package uploads!

To use the new repo add this to your Emacs config:

1
2
(add-to-list 'package-archives
'("melpa-stable" . "http://melpa-stable.milkbox.net/packages/") t)

Currently more than 500 packages are available for installation there. That number is bound to grow (a lot).

By the way, the maintainers of MELPA are looking for help to update the home page of the stable package archive. Currently it’s the same as the one of the snapshot archive, which is a bit confusing (especially regarding installation instructions). If you’d like to help fork and improve the page’s code on GitHub.

Opening Large Files

| Comments

I guess everyone has seen the following warning (at some point or another) when trying to open a relatively large file in Emacs:

1
File foo.bar is large (XX.XM), really open?

By default Emacs will display this warning for every file bigger than 10MB, which is quite annoying (conservative), especially given the fact that on any modern computer even much bigger files will be loaded almost instantaneously and won’t slow down Emacs significantly.

You can adjust this behavior by altering the value of the large-file-warning-threshold variable. I’d suggest setting it to something like 100MB:

1
2
;; warn when opening files bigger than 100MB
(setq large-file-warning-threshold 100000000)

Alternative, you can set it to nil, which will suppress the warning permanently, regardless of the size of the file you’re trying to open.

P.S. By the way, it’s not particularly wise to edit huge files (say bigger than 1GB) in Emacs directly. If you need to do something like this I’d suggest taking a look at the excellent vlfi package.