Merge branch 'master' of ssh://alanpearce.eu/dotfiles

2 files changed, 787 insertions, 877 deletions

diff --git a/emacs/.emacs.d/Makefile b/emacs/.emacs.d/Makefile
index 7741ef3..71415d5 100644
--- a/emacs/.emacs.d/Makefile
+++ b/emacs/.emacs.d/Makefile
@@ -1,11 +1,4 @@
-define EMACS_TANGLE
-(progn\
-  (package-refresh-contents nil)\
-  (setq vc-follow-symlinks nil)\
-  (find-file \"init.org\")\
-  (require 'ob-tangle)\
-  (org-babel-tangle nil \"init.el\"))
-endef
+EMACS := ${NIX_LINK}/bin/emacs
 
 # The first target is the default.  `all` is typically defined here.
 all: init.elc
@@ -13,11 +6,8 @@ all: init.elc
 # These targets don't pertain to files
 .PHONY: all clean
 
-init.el:
-	@emacs --batch --no-init-file --eval "$(EMACS_TANGLE)" --kill
-
 init.elc: init.el
-	@emacs --batch --no-init-file --funcall batch-byte-compile init.el
+	$(EMACS) --batch --no-init-file --funcall batch-byte-compile init.el
 
 clean:
-	rm init.el init.elc
+	rm init.elc
diff --git a/emacs/.emacs.d/init.org b/emacs/.emacs.d/init.el
index 1ad5426..1880871 100644
--- a/emacs/.emacs.d/init.org
+++ b/emacs/.emacs.d/init.el
@@ -1,62 +1,65 @@
-#+TITLE: Emacs Configuration for Alan Pearce
-#+OPTIONS: ^:nil
-#+PROPERTY: results silent
-#+PROPERTY: eval no-export
-#+PROPERTY: header-args :comments link
-* Introduction
-This is a living document, detailing my Emacs configuration using org-mode
-* Basics
-** Startup
-Open Emacs with just a plain window.  No graphics or messages, please!
-#+BEGIN_SRC emacs-lisp
+;;; emacs-config --- Summary
+;; #+TITLE: Emacs Configuration for Alan Pearce
+;; #+OPTIONS: ^:nil
+;; #+PROPERTY: results silent
+;; #+PROPERTY: eval no-export
+;; #+PROPERTY: header-args :comments link
+;;; Header:
+;; This is a living document, detailing my Emacs configuration using org-mode
+;;; Code:
+;; ** Basics
+;; *** Startup
+;; Open Emacs with just a plain window.  No graphics or messages, please!
+;; #+BEGIN_SRC emacs-lisp
 (put 'inhibit-startup-echo-area-message 'saved-value
      (setq inhibit-startup-echo-area-message (user-login-name)))
 (setq inhibit-startup-screen t)
 (setq gc-cons-threshold 100000000)
-(defvar file-name-handler-alist-backup file-name-handler-alist)
-(setq file-name-handler-alist nil)
+(add-hook 'after-init-hook
+          (lambda ()
+            (setq gc-cons-threshold 800000)))
 (remove-hook 'find-file-hooks #'vc-refresh-state)
-#+END_SRC
+;; #+END_SRC
 
-Are we running on Windows via the WSL?
+;; Are we running on Windows via the WSL?
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (when (file-exists-p "/proc/sys/kernel/osrelease")
   (with-temp-buffer
     (insert-file-contents-literally "/proc/sys/kernel/osrelease")
     (decode-coding-region (point-min) (point-max) 'utf-8 t)
     (when (string-match "Microsoft$" (buffer-string))
       (setq system-type 'gnu/linux/windows))))
-#+END_SRC
+;; #+END_SRC
 
-** Compatibility
+;; *** Compatibility
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (if (version< emacs-version "25.0")
     (defmacro with-eval-after-load (file &rest body)
       `(eval-after-load ,file (lambda () ,@body))))
-#+END_SRC
+;; #+END_SRC
 
-** Scratch buffers
-I usually use scratch buffers for any sort of text.  If I need a
-programming mode in one, then I’ll just call it manually.  I also like
-the buffer to be empty.
-#+BEGIN_SRC emacs-lisp
+;; *** Scratch buffers
+;; I usually use scratch buffers for any sort of text.  If I need a
+;; programming mode in one, then I’ll just call it manually.  I also like
+;; the buffer to be empty.
+;; #+BEGIN_SRC emacs-lisp
 (setq initial-scratch-message ""
       initial-major-mode 'text-mode)
-#+END_SRC
+;; #+END_SRC
 
-** Personal Information
-#+BEGIN_SRC emacs-lisp
+;; *** Personal Information
+;; #+BEGIN_SRC emacs-lisp
 (setq user-mail-address "alan@alanpearce.eu"
       user-full-name "Alan Pearce")
-#+end_src
+;; #+end_src
 
-* Packaging
+;; ** Packaging
 
-** Use-package
+;; *** Use-package
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (eval-and-compile
   (require 'seq)
   (defvar nix-emacs (and (string-match "^/nix/store" invocation-directory)
@@ -98,44 +101,44 @@ the buffer to be empty.
 (setq use-package-always-ensure (not nix-emacs)
       use-package-always-demand (daemonp)
       package-enable-at-startup nil)
-#+END_SRC
+;; #+END_SRC
 
-** Helpers
+;; *** Helpers
 
-*** Hook Helpers
+;; **** Hook Helpers
 
-An improvement over add-hook with lamda functions that allows
-modification and removal, without the boilerplate of an extra function
-definition.
+;; An improvement over add-hook with lamda functions that allows
+;; modification and removal, without the boilerplate of an extra function
+;; definition.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (eval-and-compile
   (use-package hook-helpers))
-#+END_SRC
+;; #+END_SRC
 
-* Customize
-I don’t really like using customize for normal configuration.
-Instead, I use it for things that get saved automatically.  That’s why
-I use a different file, which is ignored by the VCS.  It also means
-that it’s not important whether the file exists or not, which is why I
-pass =:noerror= to =load=
+;; ** Customize
+;; I don’t really like using customize for normal configuration.
+;; Instead, I use it for things that get saved automatically.  That’s why
+;; I use a different file, which is ignored by the VCS.  It also means
+;; that it’s not important whether the file exists or not, which is why I
+;; pass =:noerror= to =load=
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (setq custom-file "~/.emacs.d/custom.el")
 (load custom-file :noerror :nomessage)
-#+END_SRC
+;; #+END_SRC
 
-* Styles
+;; ** Styles
 
-I prefer an always-visible cursor.  Feels less distracting.
-#+BEGIN_SRC emacs-lisp
+;; I prefer an always-visible cursor.  Feels less distracting.
+;; #+BEGIN_SRC emacs-lisp
 (when (fboundp #'blink-cursor-mode)
   (blink-cursor-mode -1))
-#+END_SRC
+;; #+END_SRC
 
-Disable all the bars, unless on OSX, in which case, keep the menu bar.
+;; Disable all the bars, unless on OSX, in which case, keep the menu bar.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (when (and menu-bar-mode (not (eq window-system 'ns)))
   (menu-bar-mode -1))
 (with-eval-after-load 'scroll-bar
@@ -144,23 +147,23 @@ Disable all the bars, unless on OSX, in which case, keep the menu bar.
   (tooltip-mode -1))
 (with-eval-after-load 'tool-bar
   (tool-bar-mode -1))
-#+END_SRC
+;; #+END_SRC
 
-Ring the bell sometimes, but not so often
-#+BEGIN_SRC emacs-lisp
+;; Ring the bell sometimes, but not so often
+;; #+BEGIN_SRC emacs-lisp
 (setq ring-bell-function
       (lambda ()
         (unless (memq this-command
                       '(isearch-abort abort-recursive-edit exit-minibuffer keyboard-quit undo-tree-undo))
           (ding))))
-#+END_SRC
+;; #+END_SRC
 
-** Colours
+;; *** Colours
 
-Eziam looks nice, too, except for the non-white background.  I prefer
-white because most other application backgrounds are that colour.
+;; Eziam looks nice, too, except for the non-white background.  I prefer
+;; white because most other application backgrounds are that colour.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package eziam-light-theme
   :ensure eziam-theme
   :disabled t
@@ -178,11 +181,11 @@ white because most other application backgrounds are that colour.
                                     '(git-gutter-fr:added ((t (:foreground "#96a4ab"))))
                                     '(git-gutter-fr:modified ((t (:foreground "#96a4ab"))))
                                     '(git-gutter-fr:deleted ((t (:foreground "#96a4ab")))))))
-#+END_SRC
+;; #+END_SRC
 
-White-theme.  Sounds like a good idea.
+;; White-theme.  Sounds like a good idea.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package white-theme
   :if (or window-system
           (daemonp))
@@ -193,30 +196,30 @@ White-theme.  Sounds like a good idea.
                                     '(git-gutter-fr:modified ((t (:foreground "#b8b8b8"))))
                                     '(git-gutter-fr:deleted ((t (:foreground "#b8b8b8"))))
                                     '(font-lock-string-face ((t (:slant normal)))))))
-#+END_SRC
+;; #+END_SRC
 
-Base16 theming allows me have a consistent style between applications
-quite easily.
+;; Base16 theming allows me have a consistent style between applications
+;; quite easily.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package base16-theme
   :if (or window-system
           (daemonp)))
-#+END_SRC
+;; #+END_SRC
 
-Highlighting quasi-quoted expressions in lisps is quite useful, but I
-don't need it all the time.  I'll keep it around for a while so that I
-can enable it if needed.
-#+BEGIN_SRC emacs-lisp
+;; Highlighting quasi-quoted expressions in lisps is quite useful, but I
+;; don't need it all the time.  I'll keep it around for a while so that I
+;; can enable it if needed.
+;; #+BEGIN_SRC emacs-lisp
 (use-package highlight-stages
   :diminish highlight-stages-mode)
-#+END_SRC
+;; #+END_SRC
 
-** Fonts
+;; *** Fonts
 
-When possible, set up fonts.  I don’t have any settings here for X11,
-because I manage those in my [[file:~/projects/dotfiles/tag-xresources/xresources/main][XResources file]].
-#+BEGIN_SRC emacs-lisp
+;; When possible, set up fonts.  I don’t have any settings here for X11,
+;; because I manage those in my [[file:~/projects/dotfiles/tag-xresources/xresources/main][XResources file]].
+;; #+BEGIN_SRC emacs-lisp
 (when (or (display-graphic-p)
           (daemonp))
 
@@ -258,33 +261,33 @@ because I manage those in my [[file:~/projects/dotfiles/tag-xresources/xresource
       (ap/set-fonts "Noto Mono" 12 "Sans" 12 nil))))
 
   (ap/set-fonts-according-to-system))
-#+END_SRC
+;; #+END_SRC
 
-Reduce font decoration.  I’m trying to see whether this helps me focus
-on the right things.
-#+BEGIN_SRC emacs-lisp
+;; Reduce font decoration.  I’m trying to see whether this helps me focus
+;; on the right things.
+;; #+BEGIN_SRC emacs-lisp
 (setq font-lock-maximum-decoration '((dired-mode . 1)
                                      (t . 1)))
-#+END_SRC
+;; #+END_SRC
 
-Make symbols prettier.  Turns out, in many cases, this is already
-configured, just not enabled.  If using the mac-port version of Emacs,
-it has it's own, more extensive version.
+;; Make symbols prettier.  Turns out, in many cases, this is already
+;; configured, just not enabled.  If using the mac-port version of Emacs,
+;; it has it's own, more extensive version.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (if (eq window-system 'mac)
     (mac-auto-operator-composition-mode +1)
     (global-prettify-symbols-mode +1))
-#+END_SRC
+;; #+END_SRC
 
-** Page Breaks
+;; *** Page Breaks
 
-By default, Emacs displays page breaks as ^L.  Lines look much nicer.
-On Windows, Emacs incorrectly detects that U+2500 (Box Drawings Light
-Horizontal) can only be displayed with a different font, which is not
-correct, at least for Liberation Mono.
+;; By default, Emacs displays page breaks as ^L.  Lines look much nicer.
+;; On Windows, Emacs incorrectly detects that U+2500 (Box Drawings Light
+;; Horizontal) can only be displayed with a different font, which is not
+;; correct, at least for Liberation Mono.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package page-break-lines
   :defer 5
   :diminish page-break-lines-mode
@@ -294,10 +297,10 @@ correct, at least for Liberation Mono.
               (set-fontset-font "fontset-default"
                                 (cons page-break-lines-char page-break-lines-char)
                                 (face-attribute 'default :family)))))
-#+END_SRC
-** Modeline
+;; #+END_SRC
+;; *** Modeline
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (column-number-mode -1)
 (line-number-mode -1)
 (size-indication-mode t)
@@ -323,13 +326,13 @@ correct, at least for Liberation Mono.
                                          ")"))
                                '(buffer-file-name " — %f")
                                '(dired-directory (" — " dired-directory))))
-#+END_SRC
+;; #+END_SRC
 
-** Chrome
+;; *** Chrome
 
-Sometimes I like to hide clutter.  Other times, it's useful.
+;; Sometimes I like to hide clutter.  Other times, it's useful.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (defvar mode-line-default-format mode-line-format)
 (defvar mode-line-default-hidden nil
   "Whether to hide the mode line by default")
@@ -381,26 +384,26 @@ Sometimes I like to hide clutter.  Other times, it's useful.
 
 (add-hook 'minibuffer-setup-hook #'show-mode-line)
 (add-hook 'minibuffer-exit-hook #'hide-mode-line)
-#+END_SRC
+;; #+END_SRC
 
-** Highlight Changes
+;; *** Highlight Changes
 
-Highlight what just changed when I undo, yank, and so on.
+;; Highlight what just changed when I undo, yank, and so on.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package volatile-highlights
   :diminish volatile-highlights-mode
   :config (progn
             (volatile-highlights-mode t)))
-#+END_SRC
+;; #+END_SRC
 
-** Beacon
+;; *** Beacon
 
-I was against the idea of having flashy animations inside Emacs, but
-this one is useful.  It highlights the cursor when scrolling or
-switching windows.
+;; I was against the idea of having flashy animations inside Emacs, but
+;; this one is useful.  It highlights the cursor when scrolling or
+;; switching windows.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package beacon
   :diminish beacon-mode
   :config (progn
@@ -409,14 +412,14 @@ switching windows.
                   beacon-blink-duration 0.25
                   beacon-size 20
                   beacon-color "#a1b56c")))
-#+END_SRC
+;; #+END_SRC
 
-** Renaming major modes
+;; *** Renaming major modes
 
-Diminishing major modes does not happen in the same manner as minor
-modes.
+;; Diminishing major modes does not happen in the same manner as minor
+;; modes.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (unless (version<= emacs-version "24.4")
   (use-package cyphejor
     :defer 2
@@ -433,20 +436,20 @@ modes.
                                      ("mode"        "")
                                      ("shell"       "sh" :postfix)))
               (cyphejor-mode 1))))
-#+END_SRC
+;; #+END_SRC
 
 
-* Environment Variables
+;; ** Environment Variables
 
-MacOS doesn’t have a reasonable way to set environment variables and
-read them automatically any more.  So, let’s use the
-[[https://github.com/purcell/exec-path-from-shell][exec-path-from-shell]] package to set up ~exec-path~ and similar
-variables from whatever my shell configuration is.
+;; MacOS doesn’t have a reasonable way to set environment variables and
+;; read them automatically any more.  So, let’s use the
+;; [[https://github.com/purcell/exec-path-from-shell][exec-path-from-shell]] package to set up ~exec-path~ and similar
+;; variables from whatever my shell configuration is.
 
-On Windows, I like to run Emacs from the system tray menu of VcXsrv.
-It starts up without an environment in this case as well.
+;; On Windows, I like to run Emacs from the system tray menu of VcXsrv.
+;; It starts up without an environment in this case as well.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package exec-path-from-shell
   :if (or (eq system-type 'darwin)
           (eq system-type 'gnu/linux/windows)
@@ -455,15 +458,15 @@ It starts up without an environment in this case as well.
   :config (progn
             (setq exec-path-from-shell-arguments '("-l"))
             (exec-path-from-shell-initialize)))
-#+END_SRC
+;; #+END_SRC
 
-** NixOS sandboxes
+;; *** NixOS sandboxes
 
-I'm currently exploring using nix to create sandboxes for
-development.  This package allows using tools from inside sandboxes,
-and some convenience commands for building packages and launching shells.
+;; I'm currently exploring using nix to create sandboxes for
+;; development.  This package allows using tools from inside sandboxes,
+;; and some convenience commands for building packages and launching shells.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package nix-sandbox
   :config (progn
             (with-eval-after-load 'flycheck
@@ -477,16 +480,16 @@ and some convenience commands for building packages and launching shells.
                       (if (nix-current-sandbox)
                           (nix-executable-find (nix-current-sandbox) cmd)
                         (executable-find cmd)))))))
-#+END_SRC
+;; #+END_SRC
 
-* Keybindings
+;; ** Keybindings
 
-I think =set-keyboard-coding-system= stops OS X from doing something
-annoying to add accents.  The modifier setup is to match my
-re-arrangement of modifiers on OSX: Cmd on the outside, then
-Option/alt, then Control.
+;; I think =set-keyboard-coding-system= stops OS X from doing something
+;; annoying to add accents.  The modifier setup is to match my
+;; re-arrangement of modifiers on OSX: Cmd on the outside, then
+;; Option/alt, then Control.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (when (eq system-type 'darwin)
   (set-keyboard-coding-system nil)
   (custom-set-variables
@@ -498,9 +501,9 @@ Option/alt, then Control.
    '(mac-right-command-modifier 'left)
    '(mac-function-modifier 'hyper))
   (unbind-key "s-x"))
-#+END_SRC
+;; #+END_SRC
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (unbind-key "<f4>")
 (bind-key* "<f5>" #'compile)
 (bind-key* "<f6>" #'kmacro-start-macro-or-insert-counter)
@@ -531,14 +534,14 @@ Option/alt, then Control.
 (bind-key* "s-," #'switch-to-dotfiles)
 (bind-key* "C-x M-x" #'execute-extended-command)
 (set-register ?z `(file . ,(expand-file-name ".config/zsh/zshrc" "~")))
-#+END_SRC
+;; #+END_SRC
 
-** Crux
+;; *** Crux
 
-I can replace most of the simple helper/wrapper functions in my
-configuration with crux.el
+;; I can replace most of the simple helper/wrapper functions in my
+;; configuration with crux.el
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package crux
   :bind (("M-o" . crux-smart-open-line-above)
          ("C-o" . crux-smart-open-line)
@@ -552,32 +555,32 @@ configuration with crux.el
   :init (progn
           (defalias 'delete-current-buffer-file #'crux-delete-file-and-buffer)
           (defalias 'rename-current-buffer-file #'crux-rename-file-and-buffer)))
-#+END_SRC
+;; #+END_SRC
 
-* Projects
+;; ** Projects
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (defun switch-to-dotfiles ()
   (interactive)
   (projectile-switch-project-by-name (car (split-string (shell-command-to-string "ghq list --full-path dotfiles")))))
-#+END_SRC
+;; #+END_SRC
 
-** The Silver Searcher
+;; *** The Silver Searcher
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package ag
   :defer 30
   :config (setq ag-project-root-function #'projectile-project-root))
 
 (use-package wgrep-ag
   :after ag)
-#+END_SRC
+;; #+END_SRC
 
-** Ripgrep
+;; *** Ripgrep
 
-Step over Silver Search, here comes a new challenger.
+;; Step over Silver Search, here comes a new challenger.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package ripgrep
   :if (executable-find "rg"))
 
@@ -585,14 +588,14 @@ Step over Silver Search, here comes a new challenger.
   :after (ripgrep projectile)
   :if (executable-find "rg")
   :bind (("C-c p s r" . projectile-ripgrep)))
-#+END_SRC
+;; #+END_SRC
 
-** Projectile
+;; *** Projectile
 
-Projectile is awesome for working in projects, especially VCS-backed
-ones.
+;; Projectile is awesome for working in projects, especially VCS-backed
+;; ones.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package projectile
   :bind (("s-p" . projectile-switch-project)
          ("C-c C-f" . projectile-find-file)
@@ -602,7 +605,7 @@ ones.
   :demand t
   :diminish projectile-mode
   :config (progn
-            (projectile-global-mode +1)
+            (projectile-mode +1)
             (add-to-list 'projectile-globally-ignored-directories ".stversions")
 
             (defun yarn-install (&optional arg)
@@ -655,14 +658,14 @@ ones.
               "Find rg on project."
               (call-interactively #'counsel-projectile-rg))
             (define-key projectile-mode-map [remap counsel-projectile-ag] #'counsel-projectile-rg)))
-#+END_SRC
+;; #+END_SRC
 
-** vc
+;; *** vc
 
-This is nice for some things that magit doesn’t do, and for those rare
-occasions that I’m working with something other than git.
+;; This is nice for some things that magit doesn’t do, and for those rare
+;; occasions that I’m working with something other than git.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package vc
   :defer t
   :bind (("C-x v C" . vc-resolve-conflicts))
@@ -671,15 +674,15 @@ occasions that I’m working with something other than git.
             (setq vc-ignore-dir-regexp (format "\\(%s\\)\\|\\(%s\\)"
                                                vc-ignore-dir-regexp
                                                tramp-file-name-regexp))))
-#+END_SRC
+;; #+END_SRC
 
-** git-gutter-fringe
+;; *** git-gutter-fringe
 
-It’s nice to be able to see at a glance which lines of a file have
-changed.  This package colours the fringe.  I have it set to the right
-fringe so it doesn’t interfere with flycheck.
+;; It’s nice to be able to see at a glance which lines of a file have
+;; changed.  This package colours the fringe.  I have it set to the right
+;; fringe so it doesn’t interfere with flycheck.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (eval-when-compile (require 'fringe-helper))
 (use-package git-gutter-fringe
   :defer 2
@@ -699,14 +702,14 @@ fringe so it doesn’t interfere with flycheck.
               ".....XXX"
               "....XXXX")
             (setq git-gutter-fr:side 'right-fringe)))
-#+END_SRC
+;; #+END_SRC
 
-** magit
+;; *** magit
 
-Magit is my favourite way to use git.  I use selective staging all the
-time.  Make sure to set it up with a nice =completing-read-function=
+;; Magit is my favourite way to use git.  I use selective staging all the
+;; time.  Make sure to set it up with a nice =completing-read-function=
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package magit
   :defer 5
   :commands (magit-status)
@@ -716,59 +719,59 @@ time.  Make sure to set it up with a nice =completing-read-function=
                        global-magit-file-mode nil)
                  (add-to-list 'magit-no-confirm 'safe-with-wip))
   :init (add-hook 'magit-mode-hook #'magit-load-config-extensions))
-#+END_SRC
+;; #+END_SRC
 
-** git-messenger
+;; *** git-messenger
 
-Popup the last commit that changed the line at point.
+;; Popup the last commit that changed the line at point.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package git-messenger
   :bind* (("C-x v p" . git-messenger:popup-message))
   :config (progn
             (setq git-messenger:use-magit-popup t)))
-#+END_SRC
+;; #+END_SRC
 
-** git-timemachine
+;; *** git-timemachine
 
-This package allow me to go through a file’s history with just a few
-keys.  It makes it very easy to figure what what exactly was in a file
-in the past.  I often find it useful when I remember writing something
-a particular way, but it changed later.
+;; This package allow me to go through a file’s history with just a few
+;; keys.  It makes it very easy to figure what what exactly was in a file
+;; in the past.  I often find it useful when I remember writing something
+;; a particular way, but it changed later.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package git-timemachine
   :commands git-timemachine)
-#+END_SRC
+;; #+END_SRC
 
-** ghq
+;; *** ghq
 
-[[https://github.com/motemen/ghq][=ghq=]] clones VCS-backed projects to a common directory.  It should
-seem familiar to anyone who's used =go get= before.  [[https://github.com/rcoedo/emacs-ghq][=emacs-ghq=]] is a
-simple wrapper for it.
+;; [[https://github.com/motemen/ghq][=ghq=]] clones VCS-backed projects to a common directory.  It should
+;; seem familiar to anyone who's used =go get= before.  [[https://github.com/rcoedo/emacs-ghq][=emacs-ghq=]] is a
+;; simple wrapper for it.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package ghq
   :if (executable-find "ghq"))
-#+END_SRC
+;; #+END_SRC
 
-* Files
+;; ** Files
 
-** Auto-saving
+;; *** Auto-saving
 
-Auto-save everything to a temporary directory, instead of cluttering
-the filesystem.  I don’t want emacs-specific lockfiles, either.
+;; Auto-save everything to a temporary directory, instead of cluttering
+;; the filesystem.  I don’t want emacs-specific lockfiles, either.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (setq auto-save-file-name-transforms `((".*" ,temporary-file-directory t))
       create-lockfiles nil)
-#+END_SRC
-** Backups
+;; #+END_SRC
+;; *** Backups
 
-I like to keep my backups out of regular folders.  I tell emacs to use
-a subfolder of its configuration directory for that.  Also, use the
-trash for deleting on OS X.
-#+BEGIN_SRC emacs-lisp
+;; I like to keep my backups out of regular folders.  I tell emacs to use
+;; a subfolder of its configuration directory for that.  Also, use the
+;; trash for deleting on OS X.
+;; #+BEGIN_SRC emacs-lisp
 (let ((backup-dir (expand-file-name "~/.emacs.d/backups/")))
   (unless (file-directory-p backup-dir)
     (make-directory backup-dir))
@@ -782,47 +785,47 @@ trash for deleting on OS X.
         (call-process (executable-find "trash")
                       nil 0 nil
                       file))))
-#+END_SRC
+;; #+END_SRC
 
-** autorevert
+;; *** autorevert
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package autorevert
   :diminish auto-revert-mode
   :init (progn
           (global-auto-revert-mode 1)
           (setq auto-revert-verbose nil
                 auto-revert-use-notify (not (eq system-type 'darwin)))))
-#+END_SRC
+;; #+END_SRC
 
-** Encoding
+;; *** Encoding
 
-UTF-8 is usually appropriate.  Note that =prefer-coding-system= expects
-only a coding system, not a coding system and line ending combination.
+;; UTF-8 is usually appropriate.  Note that =prefer-coding-system= expects
+;; only a coding system, not a coding system and line ending combination.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (prefer-coding-system 'utf-8)
 (setq-default buffer-file-coding-system 'utf-8-auto-unix)
-#+END_SRC
+;; #+END_SRC
 
-** Buffer-file management
+;; *** Buffer-file management
 
-Ask if I want to create a directory when it doesn’t exist.  This is
-especially nice when starting new projects.
+;; Ask if I want to create a directory when it doesn’t exist.  This is
+;; especially nice when starting new projects.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (defun my-create-non-existent-directory ()
   (let ((parent-directory (file-name-directory buffer-file-name)))
     (when (and (not (file-exists-p parent-directory))
                (y-or-n-p (format "Directory `%s' does not exist!  Create it?" parent-directory)))
       (make-directory parent-directory t))))
 (add-to-list 'find-file-not-found-functions #'my-create-non-existent-directory)
-#+END_SRC
+;; #+END_SRC
 
-I often want to rename or delete the file that I’m currently visiting
-with a buffer.
+;; I often want to rename or delete the file that I’m currently visiting
+;; with a buffer.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (defun kill-or-delete-this-buffer-dwim (&optional arg)
   "Kills current buffer.  With prefix arg, delete it."
   (interactive "P")
@@ -834,13 +837,13 @@ with a buffer.
         (when (equal buf "*HTTP Response*")
           (other-window 1))
         (kill-buffer buf)))))
-#+END_SRC
+;; #+END_SRC
 
-** Whitespace
+;; *** Whitespace
 
-Show bad whitespace, so that I can fix it.
+;; Show bad whitespace, so that I can fix it.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (defun show-trailing-whitespace-on ()
   (interactive)
   (setq-local show-trailing-whitespace t))
@@ -849,24 +852,24 @@ Show bad whitespace, so that I can fix it.
   (setq-local show-trailing-whitespace nil))
 (add-hook 'prog-mode-hook #'show-trailing-whitespace-on)
 (add-hook 'text-mode-hook #'show-trailing-whitespace-on)
-#+END_SRC
+;; #+END_SRC
 
-** shrink-whitespace
+;; *** shrink-whitespace
 
-DWIM whitespace removal.  So I don’t need =M-SPC=, =M-\= and =C-x o=
-for similar things any more.
+;; DWIM whitespace removal.  So I don’t need =M-SPC=, =M-\= and =C-x o=
+;; for similar things any more.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package shrink-whitespace
   :bind ("M-SPC" . shrink-whitespace))
-#+END_SRC
+;; #+END_SRC
 
-** Tramp
+;; *** Tramp
 
-Tramp is awesome.  It makes SSH feel Unix-y.  The proxy setup is so
-that I can sudo on remote machines
+;; Tramp is awesome.  It makes SSH feel Unix-y.  The proxy setup is so
+;; that I can sudo on remote machines
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package tramp
   :defer 7
   :config (progn
@@ -886,61 +889,61 @@ that I can sudo on remote machines
             (add-to-list 'tramp-default-proxies-alist '(nil "\\`root\\'" (concat "/" tramp-default-method ":%h:")))
             (add-to-list 'tramp-default-proxies-alist `(,(regexp-quote (system-name)) nil nil))
             (add-to-list 'tramp-default-proxies-alist '("localhost" nil nil))))
-#+END_SRC
+;; #+END_SRC
 
-** ediff
+;; *** ediff
 
-I like a horizonal diff setup, with everything in one frame.
+;; I like a horizonal diff setup, with everything in one frame.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package ediff
   :defer t
   :config (progn
             (setq ediff-split-window-function 'split-window-horizontally
                   ediff-window-setup-function 'ediff-setup-windows-plain)))
-#+END_SRC
+;; #+END_SRC
 
-* Indentation
+;; ** Indentation
 
-Ah, a complicated topic.  One day we’ll all be using elastic
-tabstops.  I’ve recently switched to using two spaces, since elastic
-tabstops is probably never going to happen.
+;; Ah, a complicated topic.  One day we’ll all be using elastic
+;; tabstops.  I’ve recently switched to using two spaces, since elastic
+;; tabstops is probably never going to happen.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (setq-default tab-width 2
               indent-tabs-mode nil)
 (electric-indent-mode +1)
-#+END_SRC
+;; #+END_SRC
 
 
-** smart-tabs-mode
+;; *** smart-tabs-mode
 
-Not related to [[smart-tab][=smart-tab=]], this mode indents with tabs and aligns
-with spaces.  Perfect!
+;; Not related to [[smart-tab][=smart-tab=]], this mode indents with tabs and aligns
+;; with spaces.  Perfect!
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package smart-tabs-mode
   :defer 1
   :config (progn
             (smart-tabs-insinuate 'c 'cperl 'python)
             (define-hook-helper php-mode ()
               (smart-tabs-mode indent-tabs-mode))))
-#+END_SRC
+;; #+END_SRC
 
-** editorconfig
+;; *** editorconfig
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package editorconfig
   :diminish "EC"
   :config (editorconfig-mode 1))
-#+END_SRC
+;; #+END_SRC
 
-** dtrt-indent-mode
+;; *** dtrt-indent-mode
 
-Sometimes people use different indentation settings.  [[https://github.com/jscheid/dtrt-indent][dtrt-indent]]
-guesses the correct settings for me.
+;; Sometimes people use different indentation settings.  [[https://github.com/jscheid/dtrt-indent][dtrt-indent]]
+;; guesses the correct settings for me.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package dtrt-indent
   :config (progn
             (define-hook-helper after-change-major-mode ()
@@ -949,25 +952,25 @@ guesses the correct settings for me.
                 (dtrt-indent-adapt)))
             (defadvice dtrt-indent-try-set-offset (after toggle-smart-tabs activate)
               (smart-tabs-mode (or indent-tabs-mode -1)))))
-#+END_SRC
+;; #+END_SRC
 
-* Security
+;; ** Security
 
-** password-store
+;; *** password-store
 
-This is a frontend to the GPG-powered =pass= program.
-#+BEGIN_SRC emacs-lisp
+;; This is a frontend to the GPG-powered =pass= program.
+;; #+BEGIN_SRC emacs-lisp
 (use-package password-store
   :defer 15
   :config (progn
             (setq password-store-password-length 16)))
-#+END_SRC
-* Buffers
+;; #+END_SRC
+;; ** Buffers
 
-** Ibuffer
-Ibuffer is quite nice for listing all buffers.
+;; *** Ibuffer
+;; Ibuffer is quite nice for listing all buffers.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package ibuffer
   :bind (("C-x C-b" . ibuffer))
   :config (progn
@@ -998,32 +1001,32 @@ Ibuffer is quite nice for listing all buffers.
                           (mode 16 16 :left :elide)
                           " "
                           filename-and-process)))))
-#+END_SRC
+;; #+END_SRC
 
-** Relative Buffer names
+;; *** Relative Buffer names
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package relative-buffers
   :defer 15
   :config (progn
             (global-relative-buffers-mode)))
-#+END_SRC
-** Narrowing
+;; #+END_SRC
+;; *** Narrowing
 
-Enable it without prompting
+;; Enable it without prompting
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (put 'narrow-to-defun  'disabled nil)
 (put 'narrow-to-page   'disabled nil)
 (put 'narrow-to-region 'disabled nil)
-#+END_SRC
+;; #+END_SRC
 
-** ace-window
+;; *** ace-window
 
-I don’t often have many windows open at once, but when I do,
-=ace-window= is really nice to jump around them in the same way that
-=ace-jump= or =avy= work.
-#+BEGIN_SRC emacs-lisp
+;; I don’t often have many windows open at once, but when I do,
+;; =ace-window= is really nice to jump around them in the same way that
+;; =ace-jump= or =avy= work.
+;; #+BEGIN_SRC emacs-lisp
 (use-package ace-window
   :bind (("s-s" . ace-window))
   :config (progn
@@ -1039,14 +1042,14 @@ I don’t often have many windows open at once, but when I do,
                                       (?, winner-undo)
                                       (?. winner-redo))
                   aw-keys '(?a ?r ?s ?t ?n ?e ?i ?o))))
-#+END_SRC
+;; #+END_SRC
 
-* Windows
+;; ** Windows
 
-Scrolling is tricky.  I use this setup to help me keep track of the
-point whilst I’m moving about.
+;; Scrolling is tricky.  I use this setup to help me keep track of the
+;; point whilst I’m moving about.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (setq scroll-conservatively 100
       scroll-margin 1
       scroll-preserve-screen-position t
@@ -1056,16 +1059,16 @@ point whilst I’m moving about.
       frame-resize-pixelwise nil)
 (if (boundp 'ns-pop-up-frames)
     (setq ns-pop-up-frames nil))
-#+END_SRC
+;; #+END_SRC
 
-** eyebrowse
+;; *** eyebrowse
 
-Workspaces, a bit like dwm.  On Windows and Linux (at least the WMs
-I'm likely to use), super+{0-9} are taken from the OS, so use meta
-instead.  On macOS, super makes a lot of sense, as it's used by most
-programs to switch between program windows or views.
+;; Workspaces, a bit like dwm.  On Windows and Linux (at least the WMs
+;; I'm likely to use), super+{0-9} are taken from the OS, so use meta
+;; instead.  On macOS, super makes a lot of sense, as it's used by most
+;; programs to switch between program windows or views.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package eyebrowse
   :config (progn
             (setq eyebrowse-new-workspace t)
@@ -1093,14 +1096,14 @@ programs to switch between program windows or views.
              ("M-8" . eyebrowse-switch-to-window-config-8)
              ("M-9" . eyebrowse-switch-to-window-config-9))
             (eyebrowse-mode +1)))
-#+END_SRC
+;; #+END_SRC
 
-* Sessions
+;; ** Sessions
 
-** Desktop
-Save my Emacs session and restore it on startup.
+;; *** Desktop
+;; Save my Emacs session and restore it on startup.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package desktop
   :ensure nil
   :config (progn
@@ -1114,59 +1117,59 @@ Save my Emacs session and restore it on startup.
             (unless (file-directory-p desktop-dirname)
               (make-directory desktop-dirname))
             (desktop-save-mode 1)))
-#+END_SRC
+;; #+END_SRC
 
-** winner
+;; *** winner
 
-Undo, for window-based commands.
+;; Undo, for window-based commands.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package winner
   :config (setq winner-boring-buffers '("*Completions*" "*Help*" "*Apropos*" "*Buffer List*" "*info*" "*Compile-Log*"))
   :init (progn
           (winner-mode 1)))
-#+END_SRC
+;; #+END_SRC
 
-** windmove
+;; *** windmove
 
-Directional window movement
+;; Directional window movement
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package windmove
   :bind (("S-<left>"  . windmove-left)
          ("S-<right>" . windmove-right)
          ("S-<up>"    . windmove-up)
          ("S-<down>"  . windmove-down)))
-#+END_SRC
-* Blogging
+;; #+END_SRC
+;; ** Blogging
 
-I have a [[https://alanpearce.uk][blog]] that I publish with hugo.
+;; I have a [[https://alanpearce.uk][blog]] that I publish with hugo.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package easy-hugo
   :config (setq easy-hugo-basedir (car (split-string (shell-command-to-string "ghq list --full-path alanpearce.uk")))
                 easy-hugo-url "https://alanpearce.uk"
                 easy-hugo-default-ext ".md"))
-#+END_SRC
+;; #+END_SRC
 
-* Completion
+;; ** Completion
 
-Make built-in completion a bit more intelligent, by adding substring
-and initial-based completion and ignoring case.
+;; Make built-in completion a bit more intelligent, by adding substring
+;; and initial-based completion and ignoring case.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (setq completion-styles '(basic initials partial-completion substring)
       completion-ignore-case t
       tab-always-indent 'complete)
-#+END_SRC
+;; #+END_SRC
 
-** Company
+;; *** Company
 
-The main choices for automatic completion in Emacs are company and
-auto-complete-mode.  I’ve not tried auto-complete-mode as company
-seems to work perfectly well for me.
+;; The main choices for automatic completion in Emacs are company and
+;; auto-complete-mode.  I’ve not tried auto-complete-mode as company
+;; seems to work perfectly well for me.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package company
   :commands (company-mode)
   :diminish "Cmpl"
@@ -1187,28 +1190,28 @@ seems to work perfectly well for me.
                 company-auto-complete-chars '(?\ ?\( ?\) ?.)
                 company-tooltip-align-annotations t
                 company-selection-wrap-around t)))
-#+END_SRC
+;; #+END_SRC
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package company-web
   :after company)
-#+END_SRC
+;; #+END_SRC
 
-* Dates & Times
+;;; ** Dates & Times
 
-** Calendar
+;; *** Calendar
 
-Weeks start on Monday for me and I prefer ISO-style dates.
-#+BEGIN_SRC emacs-lisp
+;; Weeks start on Monday for me and I prefer ISO-style dates.
+;; #+BEGIN_SRC emacs-lisp
 (use-package calendar
   :defer 1
   :config (progn
             (setq calendar-week-start-day 1)
             (calendar-set-date-style 'iso)))
-#+END_SRC
+;; #+END_SRC
 
-Sometimes I want to insert a date or time into a buffer.
-#+BEGIN_SRC emacs-lisp
+;; Sometimes I want to insert a date or time into a buffer.
+;; #+BEGIN_SRC emacs-lisp
 (defun insert-date (prefix)
   "Insert the current date.  With prefix-argument, use British format.  With
      two prefix arguments, write out the day and month name."
@@ -1226,22 +1229,22 @@ Sometimes I want to insert a date or time into a buffer.
                  ((not prefix) "%Y-%m-%d %H:%M:%S")
                  ((equal prefix '(4)) "%Y-%m-%dT%H:%M:%SZ"))))
     (insert (format-time-string format))))
-#+END_SRC
+;; #+END_SRC
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (defun yesterday-time ()
   "Provide the date/time 24 hours before the time now in the format of current-time."
   (timer-relative-time (current-time) -86400))
-#+END_SRC
+;; #+END_SRC
 
-* Directories
+;; ** Directories
 
-Dired works quite nicely, but not always in the way I want.  I don’t
-like having so many prompts for recursive operations.  Also, when I
-have two dired windows open, assume that I’m going to be
-copying/moving files between them.
+;; Dired works quite nicely, but not always in the way I want.  I don’t
+;; like having so many prompts for recursive operations.  Also, when I
+;; have two dired windows open, assume that I’m going to be
+;; copying/moving files between them.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package dired
   :defer 3
   :ensure nil
@@ -1257,11 +1260,11 @@ copying/moving files between them.
             (when (and (eq system-type 'darwin) (executable-find "gls"))
               (setq insert-directory-program (executable-find "gls")))
             (put 'dired-find-alternate-file 'disabled nil)))
-#+END_SRC
+;; #+END_SRC
 
-Don’t show uninteresting files in dired listings.
+;; Don’t show uninteresting files in dired listings.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (defun turn-on-dired-omit-mode ()
   (interactive)
   (dired-omit-mode 1))
@@ -1277,11 +1280,11 @@ Don’t show uninteresting files in dired listings.
                   dired-bind-jump nil))
   :init (progn
           (add-hook 'dired-mode-hook #'turn-on-dired-omit-mode)))
-#+END_SRC
+;; #+END_SRC
 
-Expand subfolders like a tree inside the parent
+;; Expand subfolders like a tree inside the parent
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (with-eval-after-load 'dired
   (use-package dired-subtree
     :functions (dired-subtree--get-ov
@@ -1298,121 +1301,87 @@ Expand subfolders like a tree inside the parent
                   (dired-up-directory))))
             (bind-key "^" #'dired-subtree-maybe-up dired-mode-map)
             (bind-key "i" #'dired-subtree-toggle dired-mode-map))))
-#+END_SRC
+;; #+END_SRC
 
-** Disk usage
+;; *** Disk usage
 
-Combine dired and du (disk usage).
+;; Combine dired and du (disk usage).
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package dired-du
   :after dired
   :config (progn
             (setq dired-du-size-format t)))
-#+END_SRC
+;; #+END_SRC
 
-** Dired-narrow
-One can already use dired with wildcards to browse a filtered
-directory listing, but it opens a new buffer.  Dired-narrow is a
-slightly nicer interface: with a currently-open dired buffer, use =/=
-to start filtering, =RET= to complete the filter and =g= to refresh
-the buffer, removing the filter.
+;; *** Dired-narrow
+;; One can already use dired with wildcards to browse a filtered
+;; directory listing, but it opens a new buffer.  Dired-narrow is a
+;; slightly nicer interface: with a currently-open dired buffer, use =/=
+;; to start filtering, =RET= to complete the filter and =g= to refresh
+;; the buffer, removing the filter.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (with-eval-after-load 'dired
   (use-package dired-narrow
     :bind (:map dired-mode-map
                 ("/" . dired-narrow))))
-#+END_SRC
+;; #+END_SRC
 
-* Documentation
+;; ** Documentation
 
-** ehelp
+;; *** ehelp
 
-ehelp is a less well-known package that’s part of Emacs and slightly
-improves the normal help commands, mostly by making quitting them easier.
+;; ehelp is a less well-known package that’s part of Emacs and slightly
+;; improves the normal help commands, mostly by making quitting them easier.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package ehelp
   :bind-keymap ("C-h" . ehelp-map))
-#+END_SRC
-** counsel-dash
-
-Emacs’ documentation is great to read from inside Emacs.  Counsel-dash
-helps to make documentation for other languages easier to access
-
-#+BEGIN_SRC emacs-lisp
-(defmacro ap/create-counsel-dash-hook (mode docsets)
-  (let* ((mode-s (symbol-name mode))
-         (fun (intern (concat "counsel-dash-hook-" mode-s)))
-         (hook (intern (concat mode-s "-mode-hook"))))
-    `(progn
-       (defun ,fun ()
-         (when (require 'counsel-dash nil :noerror)
-           (seq-map #'counsel-dash-install-docset
-             (seq-difference ',docsets
-                                  (helm-dash-installed-docsets)))
-           (setq-local counsel-dash-docsets ',docsets)))
-       (add-hook (quote ,hook) (function ,fun)))))
-
-(use-package counsel-dash
-  :defer 20
-  :defines counsel-dash-docsets
-  :config (progn
-            (setq counsel-dash-browser-func #'eww)
-            (ap/create-counsel-dash-hook nginx ("Nginx"))
-            (ap/create-counsel-dash-hook ansible ("Ansible"))
-            (ap/create-counsel-dash-hook php ("PHP" "Symfony"))
-            (ap/create-counsel-dash-hook twig ("Twig"))
-            (ap/create-counsel-dash-hook js2 ("JavaScript" "NodeJS" "jQuery" "Express" "SailsJS" "Lo-Dash"))
-            (ap/create-counsel-dash-hook markdown ("Markdown"))
-            (ap/create-counsel-dash-hook saltstack ("SaltStack"))
-            (ap/create-counsel-dash-hook clojure ("Clojure"))
-            (ap/create-counsel-dash-hook sql ("PostgreSQL" "MySQL"))))
-#+END_SRC
+;; #+END_SRC
 
-** discover-my-major
+;; *** discover-my-major
 
-A nicer way to browse keybindings for major modes.
+;; A nicer way to browse keybindings for major modes.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package discover-my-major
   :bind ("<f1>" . discover-my-major))
-#+END_SRC
+;; #+END_SRC
 
-** which-key
+;; *** which-key
 
-Popup keybindings following a prefix automatically.
+;; Popup keybindings following a prefix automatically.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package which-key
   :diminish which-key-mode
   :config (progn
             (which-key-mode 1)
             (which-key-setup-side-window-right-bottom)))
-#+END_SRC
+;; #+END_SRC
 
-** eldoc
+;; *** eldoc
 
-Documentation in the echo-area (where the minibuffer is displayed) is
-rather useful.
+;; Documentation in the echo-area (where the minibuffer is displayed) is
+;; rather useful.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package eldoc
   :commands (eldoc-mode)
   :diminish eldoc-mode
   :config (progn
             (setq eldoc-idle-delay 0.1)
             (eldoc-add-command 'paredit-backward-delete 'paredit-close-round)))
-#+END_SRC
-* Mail
+;; #+END_SRC
+;; ** Mail
 
-** Gnus
+;; *** Gnus
 
-At work, I use gnus for email.  Some of the setup is specific to my
-workplace, so I keep it in a host-specific, GPG-encrypted file.
+;; At work, I use gnus for email.  Some of the setup is specific to my
+;; workplace, so I keep it in a host-specific, GPG-encrypted file.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package gnus
   :config (progn
             (setq gnus-gcc-mark-as-read t
@@ -1430,14 +1399,14 @@ workplace, so I keep it in a host-specific, GPG-encrypted file.
 (with-eval-after-load "mm-decode"
   (add-to-list 'mm-discouraged-alternatives "text/html")
   (add-to-list 'mm-discouraged-alternatives "text/richtext"))
-#+END_SRC
+;; #+END_SRC
 
-** BBDB
+;; *** BBDB
 
-As I'm using Emacs for email, it makes sense to have contact
-information here as well.
+;; As I'm using Emacs for email, it makes sense to have contact
+;; information here as well.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package bbdb
   :config (progn
             (bbdb-initialize 'gnus 'message 'pgp)
@@ -1445,20 +1414,18 @@ information here as well.
             (setq bbdb-send-mail-style 'gnus
                   bbdb-complete-mail-allow-cycling t
                   bbdb-mua-auto-update t
+                  bbdb-mua-pop-up-window-size 3
                   bbdb-mua-update-interactive-p '(query . create)
                   bbdb-message-all-addresses t
                   bbdb-offer-save t
                   bbdb-offer-to-create 1)))
-#+END_SRC
+;; #+END_SRC
 
-* Misc
+;; ** Misc
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (defvar *init-file*
-  (let ((init-file (or user-init-file
-                       (expand-file-name "init.el" user-emacs-directory))))
-    (expand-file-name "init.el"
-                      (file-name-directory (file-truename init-file))))
+  (file-truename user-init-file)
   "Where the emacs init file really is, passing through symlinks.")
 (set-register ?e `(file . ,*init-file*))
 
@@ -1501,11 +1468,11 @@ information here as well.
 
 (bind-key* "M-!" #'shell-execute)
 (bind-key* "C-x r M-w" #'copy-rectangle)
-#+END_SRC
+;; #+END_SRC
 
-** Auxillary Configuration
+;; *** Auxillary Configuration
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (require 'pinentry)
 
 (defvar have-private-key
@@ -1554,38 +1521,38 @@ information here as well.
 (if (eq 1 (length (frame-list)))
     (add-hook 'after-init-hook #'load-private-data)
   (add-hook 'after-make-frame-functions #'first-frame-hook))
-#+END_SRC
+;; #+END_SRC
 
-* Minibuffer
+;; ** Minibuffer
 
-Sometimes I want to use the minibuffer, but I’m already inside it.
-Fortunately, this is possible.  Of course, I need to know how many
-minibuffers there are on the stack.
+;; Sometimes I want to use the minibuffer, but I’m already inside it.
+;; Fortunately, this is possible.  Of course, I need to know how many
+;; minibuffers there are on the stack.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (setq enable-recursive-minibuffers t)
 (minibuffer-depth-indicate-mode t)
-#+END_SRC
+;; #+END_SRC
 
-This avoids some issue with the minibuffer and the point being behind
-the prompt.  I don’t remember what exactly.
-#+BEGIN_SRC emacs-lisp
+;; This avoids some issue with the minibuffer and the point being behind
+;; the prompt.  I don’t remember what exactly.
+;; #+BEGIN_SRC emacs-lisp
 (setq minibuffer-prompt-properties '(read-only t point-entered minibuffer-avoid-prompt face minibuffer-prompt))
-#+END_SRC
+;; #+END_SRC
 
-Occasionally, I exit emacs.  I should probably reduce the frequency of this.
-#+BEGIN_SRC emacs-lisp
+;; Occasionally, I exit emacs.  I should probably reduce the frequency of this.
+;; #+BEGIN_SRC emacs-lisp
 (if (daemonp)
     (defalias 'exit-emacs #'delete-frame)
   (defalias 'exit-emacs #'save-buffers-kill-emacs))
-#+END_SRC
+;; #+END_SRC
 
-** swiper/ivy
+;; *** swiper/ivy
 
-Ivy is the new kid on the completion block.  It seems to be a strong
-replacement for helm so far.
+;; Ivy is the new kid on the completion block.  It seems to be a strong
+;; replacement for helm so far.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package swiper
   :bind (("C-s" . swiper)
          ("C-r" . swiper)
@@ -1601,11 +1568,11 @@ replacement for helm so far.
                                                          (ivy--reset-state ivy-last))
                                                    "kill")))
             (add-to-list 'ivy-initial-inputs-alist '(counsel-M-x . ""))))
-#+END_SRC
+;; #+END_SRC
 
-** counsel
+;; *** counsel
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package counsel
   :config (progn
             (bind-key "M-x" #'counsel-M-x)
@@ -1623,16 +1590,16 @@ replacement for helm so far.
                 (message "File not writable %s" buffer-file-name)
                 (find-alternate-file (concat "/sudo::" buffer-file-name))))
             (setq counsel-rg-base-command "rg -i --no-heading --line-number --hidden %s .")))
-#+END_SRC
+;; #+END_SRC
 
 
-** smex
+;; *** smex
 
-Smex is my favourite way to use =M-x=.  Counsel’s =counsel-M-x=
-function uses it internally, so I’m keeping it around, even though I
-don’t use it directly.
+;; Smex is my favourite way to use =M-x=.  Counsel’s =counsel-M-x=
+;; function uses it internally, so I’m keeping it around, even though I
+;; don’t use it directly.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package smex
   :commands (smex
              smex-update
@@ -1648,37 +1615,37 @@ don’t use it directly.
           (setq smex-history-length 100
                 smex-save-file (concat user-emacs-directory
                                        "smex-items"))))
-#+END_SRC
+;; #+END_SRC
 
-** cmd-to-echo
+;; *** cmd-to-echo
 
-I’ve been looking for some way to run programming projects (mostly
-node.js) inside emacs.  =cmd-to-echo= seems great for this, as new
-output pops up in the echo area.
+;; I’ve been looking for some way to run programming projects (mostly
+;; node.js) inside emacs.  =cmd-to-echo= seems great for this, as new
+;; output pops up in the echo area.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package cmd-to-echo
   :commands (cmd-to-echo)
   :config (setq cmd-to-echo-add-output-to-process-buffers t))
-#+END_SRC
-* Modes
+;; #+END_SRC
+;; ** Modes
 
-Setup some modes for systemd files
-#+BEGIN_SRC emacs-lisp
+;; Setup some modes for systemd files
+;; #+BEGIN_SRC emacs-lisp
 (add-to-list 'auto-mode-alist '("\\.service\\'" . conf-mode))
 (add-to-list 'auto-mode-alist '("\\.target\\'" . conf-mode))
 (add-to-list 'auto-mode-alist '("\\.socket\\'" . conf-mode))
-#+END_SRC
+;; #+END_SRC
 
-=direnv=’s files are basically shell scripts, it’s a nice way to
-set environment variables for projects.
-#+BEGIN_SRC emacs-lisp
+;; =direnv=’s files are basically shell scripts, it’s a nice way to
+;; set environment variables for projects.
+;; #+BEGIN_SRC emacs-lisp
 (add-to-list 'auto-mode-alist '("\\.envrc\\'" . sh-mode))
-#+END_SRC
+;; #+END_SRC
 
-Some modes that I don’t really customise much, mostly for
-configuration files.
-#+BEGIN_SRC emacs-lisp
+;; Some modes that I don’t really customise much, mostly for
+;; configuration files.
+;; #+BEGIN_SRC emacs-lisp
 (use-package haskell-mode
   :mode (("\\.hs\\'" . haskell-mode)))
 
@@ -1728,16 +1695,17 @@ configuration files.
 
 (define-derived-mode saltstack-mode yaml-mode "Salt")
 (add-to-list 'auto-mode-alist '("\\.sls\\'" . saltstack-mode))
-#+END_SRC
+;; #+END_SRC
 
-** ledger
+;; *** ledger
 
-I use [[http://ledger-cli.org/][=ledger=]] to manage my finances.  It has an Emacs mode, which
-works really nicely.
+;; I use [[http://ledger-cli.org/][=ledger=]] to manage my finances.  It has an Emacs mode, which
+;; works really nicely.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package ledger-mode
   :mode ("\\.ledger\\'" . ledger-mode)
+  :functions ledger-report
   :init (progn
           (defun open-budget ()
             (interactive)
@@ -1768,22 +1736,50 @@ works really nicely.
                                    ("equity" "ledger -f %(ledger-file) equity")
                                    ("payee" "ledger -f %(ledger-file) reg @%(payee)")
                                    ("account" "ledger -f %(ledger-file) reg %(account)")))))
-#+END_SRC
+;; #+END_SRC
 
-** Markdown
+;; *** Markdown
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package markdown-mode
   :defer t
   :config (progn
             (add-hook 'markdown-mode-hook #'turn-on-auto-fill)))
-#+END_SRC
+;; #+END_SRC
+
+;; *** Lentic
+
+;; Multiple different views of the same file.  Can be used for a kind of
+;; inverse literate programming.
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package lentic
+  :config (global-lentic-mode))
+;; #+END_SRC
+
+;; *** Outshine
 
-** Org
+;; Org-ified source code.  I think this might work better than
+;; lentic-mode, whilst also being more general.
 
-Org is wünderbar.
+;; #+BEGIN_SRC emacs-lisp
+(defvar outline-minor-mode-prefix "M-#")
+(use-package outshine
+  :bind (:map outline-minor-mode-map
+              ("TAB" . outline-cycle)
+              ("<backtab>" . outshine-cycle-buffer))
+  :config (progn
+            (add-hook 'outline-minor-mode-hook #'outshine-hook-function)
+            (add-hook 'emacs-lisp-mode-hook #'outline-minor-mode)
+            (add-hook 'ledger-mode-hook #'outline-minor-mode)
+            (add-hook 'sh-mode-hook #'outline-minor-mode)))
+;; #+END_SRC
+
+;; *** Org
+
+;; Org is wünderbar.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package org
   :bind (("C-c C-a" . org-agenda-list)
          ("C-c a" . org-agenda)
@@ -1837,16 +1833,16 @@ Org is wünderbar.
   :after org
   :config (progn
             (bind-key "C-x C-s" #'org-edit-src-exit org-src-mode-map)))
-#+END_SRC
+;; #+END_SRC
 
-**** org-babel
+;; ***** org-babel
 
-Org’s babel feature is really nice.  I use it for this file, and I can
-use it to communicate between programming languages.  Sometime I hope
-to have my =ledger= setup in an org file with some graph processing
-with R or something.
+;; Org’s babel feature is really nice.  I use it for this file, and I can
+;; use it to communicate between programming languages.  Sometime I hope
+;; to have my =ledger= setup in an org file with some graph processing
+;; with R or something.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package ob-core
   :defer t
   :ensure nil
@@ -1857,13 +1853,13 @@ with R or something.
             (setq org-src-tab-acts-natively t
                   org-edit-src-content-indentation 0
                   org-src-preserve-indentation t)))
-#+END_SRC
+;; #+END_SRC
 
-**** org-journal
+;; ***** org-journal
 
-I can use this to keep a journal.  I should use it.
+;; I can use this to keep a journal.  I should use it.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package org-journal
   :bind ("s-j" . org-journal-new-entry)
   :defer 20
@@ -1882,15 +1878,15 @@ I can use this to keep a journal.  I should use it.
               "Show org-journal entry for yesterday"
               (interactive)
               (org-journal-read-or-display-entry (yesterday-time)))))
-#+END_SRC
+;; #+END_SRC
 
 
-* Programming
-** flycheck
+;; ** Programming
+;; *** flycheck
 
-On-the-fly error checking in programming modes?  Yes please.
+;; On-the-fly error checking in programming modes?  Yes please.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package flycheck
   :diminish " ✓"
   :defer 5
@@ -1903,35 +1899,35 @@ On-the-fly error checking in programming modes?  Yes please.
                 ".XXX...."))
             (if (executable-find "eslint_d")
                 (setq flycheck-javascript-eslint-executable "eslint_d"))))
-#+END_SRC
+;; #+END_SRC
 
-*** flycheck-pos-tip
+;; **** flycheck-pos-tip
 
-Show flycheck errors in a little popup, so I don't lose my place
+;; Show flycheck errors in a little popup, so I don't lose my place
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package flycheck-pos-tip
   :after flycheck
   :config (progn
             (setq flycheck-display-errors-delay 0.5)
             (flycheck-pos-tip-mode 1)))
-#+END_SRC
+;; #+END_SRC
 
-*** flycheck-flow
+;; **** flycheck-flow
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package flycheck-flow
   :after js2-mode
   :if (executable-find "flow")
   :config (progn
             (flycheck-add-next-checker 'javascript-eslint 'javascript-flow)))
-#+END_SRC
+;; #+END_SRC
 
-** golang
+;; *** golang
 
-Go has a few packages to inter-operate with other emacs packages.
+;; Go has a few packages to inter-operate with other emacs packages.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package company-go
   :commands company-go
   :config (progn
@@ -1952,13 +1948,13 @@ Go has a few packages to inter-operate with other emacs packages.
             (setq go-projectile-switch-gopath 'maybe)))
 
 
-#+END_SRC
+;; #+END_SRC
 
-** ggtags
+;; *** ggtags
 
-A nice completion backend for programming modes.
+;; A nice completion backend for programming modes.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package ggtags
   :if (executable-find "gtags")
   :commands turn-on-ggtags-mode
@@ -1970,40 +1966,40 @@ A nice completion backend for programming modes.
             (interactive)
             (ggtags-mode 1))
           (add-hook 'c-mode-common-hook #'turn-on-ggtags-mode)))
-#+END_SRC
+;; #+END_SRC
 
-** dumb-jump
+;; *** dumb-jump
 
-A "clever" way of implementing go-to-definition across languages: use
-a project-wide text search and apply heuristics to the results to
-guess a definition.
+;; A "clever" way of implementing go-to-definition across languages: use
+;; a project-wide text search and apply heuristics to the results to
+;; guess a definition.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package dumb-jump
   :bind (("M-g o" . dumb-jump-go-other-window)
          ("M-g j" . dumb-jump-go)
          ("M-g x" . dumb-jump-go-prefer-external)
          ("M-g z" . dumb-jump-go-prefer-external-other-window))
   :config (setq dumb-jump-selector 'ivy))
-#+END_SRC
+;; #+END_SRC
 
-** imenu-anywhere
+;; *** imenu-anywhere
 
-This is like imenu, but shows functions (or similar top-level
-entities) across buffers in the same project.  Neat!
+;; This is like imenu, but shows functions (or similar top-level
+;; entities) across buffers in the same project.  Neat!
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package imenu-anywhere
   :bind ("C-x C-." . ivy-imenu-anywhere))
-#+END_SRC
-** Lisps
+;; #+END_SRC
+;; *** Lisps
 
-*** All
+;; **** All
 
-Lisp modes don’t seem to have a common ancestor.  So I made a custom
-hook which I trigger in every lispy-mode.
+;; Lisp modes don’t seem to have a common ancestor.  So I made a custom
+;; hook which I trigger in every lispy-mode.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (defcustom lisp-mode-common-hook nil
   "Hook run when entering any Lisp mode."
   :type 'hook
@@ -2015,79 +2011,79 @@ hook which I trigger in every lispy-mode.
           lisp-mode-hook
           clojure-mode-hook)
   (run-hooks 'lisp-mode-common-hook))
-#+END_SRC
+;; #+END_SRC
 
-**** Redshank
+;; ***** Redshank
 
-Lisp syntax allows for really easy refactoring.  Redshank gives some
-operations that aren’t part of paredit, like extracting variables into
-let bindings.
-#+BEGIN_SRC emacs-lisp
+;; Lisp syntax allows for really easy refactoring.  Redshank gives some
+;; operations that aren’t part of paredit, like extracting variables into
+;; let bindings.
+;; #+BEGIN_SRC emacs-lisp
 (use-package redshank
   :diminish " Λ"
   :after (paredit)
   :config (progn
             (add-hook 'lisp-mode-common-hook #'turn-on-redshank-mode)))
-#+END_SRC
+;; #+END_SRC
 
-*** Emacs Lisp
+;; **** Emacs Lisp
 
-Customise the modeline-display of =emacs-lisp-mode=.  Then make sure
-it runs the common lisp hooks.
+;; Customise the modeline-display of =emacs-lisp-mode=.  Then make sure
+;; it runs the common lisp hooks.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (add-hook 'emacs-lisp-mode-hook #'eldoc-mode)
-#+END_SRC
+;; #+END_SRC
 
-Go-to function for elisp.  Except it works through the entire Emacs ecosystem.
+;; Go-to function for elisp.  Except it works through the entire Emacs ecosystem.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package elisp-slime-nav
   :commands elisp-slime-nav-mode
   :diminish elisp-slime-nav-mode
   :init (progn
           (add-hook 'emacs-lisp-mode-hook #'elisp-slime-nav-mode)))
-#+END_SRC
+;; #+END_SRC
 
-Interactive elisp
+;; Interactive elisp
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package ielm
   :defer t
   :ensure nil
   :config (progn
             (define-hook-helper ielm-mode ()
               (run-hooks 'lisp-mode-common-hook))))
-#+END_SRC
+;; #+END_SRC
 
-*** Scheme & Lisp
+;; **** Scheme & Lisp
 
-I don’t work with these as often as I would like
+;; I don’t work with these as often as I would like
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (define-hook-helper lisp-mode ()
   (set (make-local-variable 'lisp-indent-function)
        #'common-lisp-indent-function))
-#+END_SRC
+;; #+END_SRC
 
-**** geiser
+;; ***** geiser
 
-A REPL thing for Scheme.  Hopefully I’ll get to use it more in the
-future.
+;; A REPL thing for Scheme.  Hopefully I’ll get to use it more in the
+;; future.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package geiser
   :commands (geiser-mode
              geiser
              run-geiser
              run-racket))
-#+END_SRC
+;; #+END_SRC
 
-**** slime
+;; ***** slime
 
-A REPL thing (and more) for Lisp.
+;; A REPL thing (and more) for Lisp.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package slime
   :commands (slime)
   :config (progn
@@ -2098,11 +2094,11 @@ A REPL thing (and more) for Lisp.
             (setq common-lisp-hyperspec-root "file://opt/local/share/doc/lisp/HyperSpec-7-0/"
                   inferior-lisp-program (or (executable-find "sbcl")
                                             (executable-find "ccl64")))))
-#+END_SRC
+;; #+END_SRC
 
-*** Clojure
+;; **** Clojure
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package clojure-mode
   :defer t
   :init (progn
@@ -2117,36 +2113,36 @@ A REPL thing (and more) for Lisp.
   :init (progn
           (define-hook-helper clojure-mode ()
             (clj-refactor-mode 1))))
-#+END_SRC
+;; #+END_SRC
 
-**** cider
+;; ***** cider
 
-A REPL thing for Clojure
+;; A REPL thing for Clojure
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package cider
   :defer t
   :config (progn
             (setq nrepl-hide-special-buffers t)
             (unbind-key "C-c C-f" cider-mode-map)
             (add-hook 'cider-mode-hook #'eldoc-mode)))
-#+END_SRC
+;; #+END_SRC
 
-** Auto-compile
+;; *** Auto-compile
 
-Auto-compile emacs lisp when saving.
-#+BEGIN_SRC emacs-lisp
+;; Auto-compile emacs lisp when saving.
+;; #+BEGIN_SRC emacs-lisp
 (use-package auto-compile
   :defer t
   :init (add-hook 'emacs-lisp-mode-hook #'auto-compile-on-save-mode))
-#+END_SRC
+;; #+END_SRC
 
-** cc-mode
+;; *** cc-mode
 
-Although I don’t use C or C++, setting up the mode is helpful because
-quite a few other modes are derived from it.
+;; Although I don’t use C or C++, setting up the mode is helpful because
+;; quite a few other modes are derived from it.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package cc-mode
   :defer 5
   :config (progn
@@ -2155,52 +2151,47 @@ quite a few other modes are derived from it.
                                     (other . "k&r"))
                   c-basic-offset 4)
             (c-set-offset 'case-label '+)))
-#+END_SRC
+;; #+END_SRC
 
-** quickrun
+;; *** quickrun
 
-It’s nice to be able to quickly evaluate some code.  Although I don’t
-really seem to use it.
-#+BEGIN_SRC emacs-lisp
+;; It’s nice to be able to quickly evaluate some code.  Although I don’t
+;; really seem to use it.
+;; #+BEGIN_SRC emacs-lisp
 (use-package quickrun
   :bind (("C-c C-e" . quickrun)))
-#+END_SRC
+;; #+END_SRC
 
-** Scala
+;; *** Scala
 
-Let’s try using Scala.
+;; Let’s try using Scala.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package scala-mode)
-#+END_SRC
+;; #+END_SRC
 
-And add ensime, an IDE-style environment.
+;; And add ensime, an IDE-style environment.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package ensime)
-#+END_SRC
+;; #+END_SRC
 
-** Web development
+;; *** Web development
 
-*** js2-mode
+;; **** js2-mode
 
-This mode is really great for editing Javascript.  It turns code into
-an AST internally, so it can work with it almost like a lisp.
+;; This mode is really great for editing Javascript.  It turns code into
+;; an AST internally, so it can work with it almost like a lisp.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package js2-mode
   :mode (("\\.js\\'" . js2-mode))
   :interpreter ("node" . js2-mode)
-  :functions js2-next-error
+  :functions (js2-next-error
+              js2--struct-put)
   :config (progn
             (define-key js2-mode-map [menu-bar Javascript] nil)
-            (defun js2--imenu-around (do-it name)
-              "Don't create a menu from js2-mode"
-              (if (and (not (string-equal name "IM-Javascript-IDE"))
-                       (fboundp #'do-it))
-                  (do-it name)))
             (add-hook 'js2-mode-hook #'js2-imenu-extras-mode)
-            (advice-add 'imenu-add-to-menubar :around #'js2--imenu-around)
             (defun ap/js2-prev-error ()
               (interactive)
               (js2-next-error -1))
@@ -2211,91 +2202,84 @@ an AST internally, so it can work with it almost like a lisp.
                   js2-include-node-externs t
                   js2-highlight-level 1
                   js2-strict-missing-semi-warning nil)))
-#+END_SRC
+;; #+END_SRC
 
-**** rjsx-mode
+;; ***** rjsx-mode
 
-A set of advice for js2-jsx-mode to work better with React.
+;; A set of advice for js2-jsx-mode to work better with React.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package rjsx-mode
+  :after js2-mode
+  :if (fboundp #'js2--struct-put)
   :mode (("\\.jsx\\'" . rjsx-mode)))
-#+END_SRC
+;; #+END_SRC
 
-**** js2-refactor
+;; ***** js2-refactor
 
-Thanks to the AST provided by js2-mode, refactoring is possible.  This
-library implements some refactorings.
+;; Thanks to the AST provided by js2-mode, refactoring is possible.  This
+;; library implements some refactorings.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package js2-refactor
   :after js2-mode
   :config (progn
             (bind-key "C-k" #'js2r-kill js2-mode-map)
             (add-hook 'js2-mode-hook #'js2-refactor-mode)
             (js2r-add-keybindings-with-prefix "C-c C-m")))
-#+END_SRC
+;; #+END_SRC
 
-**** add-node-modules-path
+;; ***** add-node-modules-path
 
-Inside a javascript project, it's common to install tools locally to
-the project.  This will allows emacs to find their executables.
+;; Inside a javascript project, it's common to install tools locally to
+;; the project.  This will allows emacs to find their executables.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package add-node-modules-path
   :config (progn
             (add-hook 'js2-mode-hook #'add-node-modules-path)))
-#+END_SRC
+;; #+END_SRC
 
-**** Flow
+;; ***** Flow
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package flow-minor-mode
   :after js2-mode
   :config (progn
             (add-hook 'js2-mode-hook #'flow-minor-enable-automatically)))
-#+END_SRC
+;; #+END_SRC
 
-**** Indium
+;; ***** Indium
 
-Javascript with an inferior node.js process and a debugger?  Awesome.
+;; Javascript with an inferior node.js process and a debugger?  Awesome.
 
-To debug with node, use version 6.9.1 or later of node and run it with
-~--inspect~ and, to break on the first line, ~--debug-brk~.
+;; To debug with node, use version 6.9.1 or later of node and run it with
+;; ~--inspect~ and, to break on the first line, ~--debug-brk~.
 
-For Chrom*, it needs to be launched with
-~--remote-debugging-port=9222~
+;; For Chrom*, it needs to be launched with
+;; ~--remote-debugging-port=9222~
 
-Node will tell you to open an URL in Chrome:
+;; Node will tell you to open an URL in Chrome:
 
-~chrome-devtools://inspector.html?...&ws=127.0.0.1:PORT/PATH~
+;; ~chrome-devtools://inspector.html?...&ws=127.0.0.1:PORT/PATH~
 
-Instead, do this:
+;; Instead, do this:
 
-~M-x indium-connect-to-nodejs RET 127.0.0.1 RET PORT RET~
+;; ~M-x indium-connect-to-nodejs RET 127.0.0.1 RET PORT RET~
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package indium
   :diminish (indium-interaction-mode . "In")
   :config (progn
             (add-hook 'js2-mode-hook #'indium-interaction-mode)))
-#+END_SRC
-
-*** coffee-mode
+;; #+END_SRC
 
-#+BEGIN_SRC emacs-lisp
-(use-package coffee-mode
-  :mode ("\\.coffee\\'" . coffee-mode)
-  :config (progn
-            (setq coffee-indent-like-python-mode t)))
-#+END_SRC
+;; **** tern
 
-*** tern
+;; Tern understands javascript.  It adds really clever documented
+;; completions, besides other IDE-like things.
 
-Tern understands javascript.  It adds really clever documented
-completions, besides other IDE-like things.
-
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package tern
   :diminish tern-mode
   :if (executable-find "tern")
@@ -2309,25 +2293,25 @@ completions, besides other IDE-like things.
 
 (with-eval-after-load 'tern
   (use-package company-tern))
-#+END_SRC
+;; #+END_SRC
 
-*** json-mode
+;; **** json-mode
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package json-mode
   :mode (("\\.json\\'" . json-mode)
          ("\\.sailsrc\\'" . json-mode)
          ("composer\\.lock\\'" . json-mode)
          ("\\.tern-project\\'" . json-mode)))
-#+END_SRC
+;; #+END_SRC
 
-*** restclient
+;; **** restclient
 
-Restclient is really nice.  It’s like a scratchpad for HTTP api
-calls.  Feels a bit like using =org-babel=.  I wonder if there’s an
-integration between the two yet.
+;; Restclient is really nice.  It’s like a scratchpad for HTTP api
+;; calls.  Feels a bit like using =org-babel=.  I wonder if there’s an
+;; integration between the two yet.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package restclient
   :mode ("\\.api\\'" . restclient-mode)
   :config (progn
@@ -2340,22 +2324,22 @@ integration between the two yet.
 (use-package company-restclient
   :after (company restclient)
   :init (add-to-list 'company-backends #'company-restclient t))
-#+END_SRC
+;; #+END_SRC
 
-*** sgml-mode
+;; **** sgml-mode
 
-This is for HTML, since old versions of HTML were derived from SGML.
-#+BEGIN_SRC emacs-lisp
+;; This is for HTML, since old versions of HTML were derived from SGML.
+;; #+BEGIN_SRC emacs-lisp
 (use-package sgml-mode
   :defer t
   :config (setq sgml-basic-offset 2))
-#+END_SRC
+;; #+END_SRC
 
-*** emmet-mode
+;; **** emmet-mode
 
-Emmet is really nice to write HTML quickly.  Especially with
-frameworks that require multiple nested elements to do anything useful.
-#+BEGIN_SRC emacs-lisp
+;; Emmet is really nice to write HTML quickly.  Especially with
+;; frameworks that require multiple nested elements to do anything useful.
+;; #+BEGIN_SRC emacs-lisp
 (use-package emmet-mode
   :commands (emmet-mode)
   :diminish (emmet-mode . " >")
@@ -2365,15 +2349,15 @@ frameworks that require multiple nested elements to do anything useful.
           (add-hook 'sgml-mode-hook #'emmet-mode)
           (add-hook 'web-mode-hook #'emmet-mode)
           (add-hook 'css-mode-hook #'emmet-mode)))
-#+END_SRC
+;; #+END_SRC
 
-*** web-mode
+;; **** web-mode
 
-This mode handles just about every templating language out ther, which
-is really nice, because it handles the HTML part the same way in all
-of them as well.
+;; This mode handles just about every templating language out ther, which
+;; is really nice, because it handles the HTML part the same way in all
+;; of them as well.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package web-mode
   :mode (("/views/.*\\.php\\'" . web-mode)
          ("\\.html\\'" . web-mode)
@@ -2390,20 +2374,13 @@ of them as well.
                   web-mode-enable-auto-pairing nil
                   web-mode-enable-auto-quoting nil)
             (sp-local-pair '(web-mode) "<%" "%>")))
-#+END_SRC
-
-I derived a mode for twig, in order to use its =mode-hook=.
-
-#+BEGIN_SRC emacs-lisp
-(define-derived-mode twig-mode web-mode "Twig")
-(add-to-list 'auto-mode-alist '("\\.html\\.twig\\'" . twig-mode))
-#+END_SRC
+;; #+END_SRC
 
-** Live coding
+;; *** Live coding
 
-Sometimes I might want to show off my emacs usage.
+;; Sometimes I might want to show off my emacs usage.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (defun live-coding ()
   (interactive)
   (ap/set-fonts "SF Mono" 18 nil nil t 0.1)
@@ -2413,22 +2390,22 @@ Sometimes I might want to show off my emacs usage.
   (interactive)
   (ap/set-fonts-according-to-system)
   (global-command-log-mode -1))
-#+END_SRC
+;; #+END_SRC
 
-*** command-log-mode
+;; **** command-log-mode
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package command-log-mode
   :defines command-log-mode-key-binding-open-log
   :init (progn
           (setq command-log-mode-key-binding-open-log nil
                 command-log-mode-auto-show t
                 command-log-mode-is-global t)))
-#+END_SRC
+;; #+END_SRC
 
-* Spelling
+;; ** Spelling
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package ispell
   :bind (("<f8>" . ispell-word))
   :config (progn
@@ -2440,9 +2417,9 @@ Sometimes I might want to show off my emacs usage.
              ((executable-find "hunspell") (setq ispell-program-name "hunspell"
                                                  ispell-really-aspell nil
                                                  ispell-really-hunspell t)))))
-#+END_SRC
+;; #+END_SRC
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package flyspell
   :diminish "﹏"
   :config (progn
@@ -2488,26 +2465,26 @@ Sometimes I might want to show off my emacs usage.
               (setq-local ispell-extra-args (flyspell-detect-ispell-args)))
             (add-hook 'text-mode-hook 'fly-text-mode-hook-setup)
             (add-hook 'prog-mode-hook #'flyspell-prog-mode)))
-#+END_SRC
+;; #+END_SRC
 
-** Style checking
+;; *** Style checking
 
-[[https://github.com/ValeLint/vale][Vale]] is a linter, but for prose.  Neat idea!  Salesman is a bad term.
+;; [[https://github.com/ValeLint/vale][Vale]] is a linter, but for prose.  Neat idea!  Salesman is a bad term.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package flycheck-vale
   :if (executable-find "vale")
   :config (progn
             (add-to-list 'flycheck-vale-modes 'org-mode)
             (add-to-list 'flycheck-vale-modes 'org-journal-mode)
             (flycheck-vale-setup)))
-#+END_SRC
+;; #+END_SRC
 
-* Scripting
+;; ** Scripting
 
-Make a shell-script buffer executable after saving it, if it has a shebang.
+;; Make a shell-script buffer executable after saving it, if it has a shebang.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (add-hook 'after-save-hook
           #'executable-make-buffer-file-executable-if-script-p)
 
@@ -2518,18 +2495,18 @@ Make a shell-script buffer executable after saving it, if it has a shebang.
   :config (setq sh-shell-file "/usr/bin/env zsh"
                 sh-indentation 2
                 sh-basic-offset 2))
-#+END_SRC
+;; #+END_SRC
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (add-hook 'shell-mode-hook 'ansi-color-for-comint-mode-on)
-#+END_SRC
+;; #+END_SRC
 
-** eshell
+;; *** eshell
 
-I should try to get into the habit of using this more.  It’s really
-nice, when I remember to use it.
+;; I should try to get into the habit of using this more.  It’s really
+;; nice, when I remember to use it.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package eshell
   :bind ("C-c s" .  eshell)
   :defer 10
@@ -2562,11 +2539,11 @@ nice, when I remember to use it.
 (bind-key "C-c S" #'eshell-goto-current-dir)
 
 
-#+END_SRC
+;; #+END_SRC
 
-*** Shells
+;; **** Shells
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package shell
   :defer t
   :ensure nil
@@ -2583,26 +2560,26 @@ nice, when I remember to use it.
   (if (null (get-buffer-process (current-buffer)))
       (kill-buffer)
     (comint-delchar-or-maybe-eof arg)))
-#+END_SRC
+;; #+END_SRC
 
-* Text editing
+;; ** Text editing
 
-Emacs has an editor within.
+;; Emacs has an editor within.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (put 'upcase-region 'disabled nil)
 (put 'downcase-region 'disabled nil)
 (setq sentence-end-double-space t
       line-move-visual nil)
 (setq-default truncate-lines t)
-#+END_SRC
+;; #+END_SRC
 
-** align
+;; *** align
 
-=Align= is a useful command to line things up, once given some rules.
-The most important one for me is JSON property alignment.
+;; =Align= is a useful command to line things up, once given some rules.
+;; The most important one for me is JSON property alignment.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package align
   :defer 10
   :ensure nil
@@ -2611,64 +2588,64 @@ The most important one for me is JSON property alignment.
                          '(colon-key-value
                            (regexp . ":\\(\\s-*\\)")
                            (modes  . '(js2-mode))))))
-#+END_SRC
+;; #+END_SRC
 
-** Clipboard
+;; *** Clipboard
 
-I like to use the clipboard more than the primary selection in X11.
+;; I like to use the clipboard more than the primary selection in X11.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (setq select-enable-clipboard t
       save-interprogram-paste-before-kill t)
 (if (functionp 'x-cut-buffer-or-selection-value)
     (setq interprogram-paste-function 'x-cut-buffer-or-selection-value))
 (when (boundp 'x-select-request-type)
   (setq x-select-request-type '(UTF8_STRING COMPOUND_TEXT TEXT STRING)))
-#+END_SRC
+;; #+END_SRC
 
-** Selection
+;; *** Selection
 
-I’m quite used to deleting text by selecting it and typing.  Emacs has
-a mode for that.
+;; I’m quite used to deleting text by selecting it and typing.  Emacs has
+;; a mode for that.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package delsel
   :config (delete-selection-mode t))
-#+END_SRC
+;; #+END_SRC
 
-Sub-word movement is really nice for camel- and Pascal-case
+;; Sub-word movement is really nice for camel- and Pascal-case
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package subword
   :diminish subword-mode
   :init (global-subword-mode t))
-#+END_SRC
+;; #+END_SRC
 
-I find that =zap-up-to-char= normally makes more sense to me than
-=zap-to-char=.
+;; I find that =zap-up-to-char= normally makes more sense to me than
+;; =zap-to-char=.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package misc
   :ensure nil
   :bind (("M-z" . zap-up-to-char)
          ("M-Z" . zap-to-char)))
-#+END_SRC
+;; #+END_SRC
 
-Expanding the region by semantic units was something I quite liked
-from Sublime Text.  As always, there’s a mode for that.
+;; Expanding the region by semantic units was something I quite liked
+;; from Sublime Text.  As always, there’s a mode for that.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package expand-region
   :bind ("C-M-SPC" . er/expand-region)
   :config (setq expand-region-fast-keys-enabled nil))
-#+END_SRC
+;; #+END_SRC
 
-** avy
+;; *** avy
 
-Avy is a really nice way to move around files, like ace-jump-mode, but
-somehow I prefer it.
+;; Avy is a really nice way to move around files, like ace-jump-mode, but
+;; somehow I prefer it.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package avy
   :defer 5
   :bind (("M-g g" . avy-goto-line)
@@ -2680,13 +2657,13 @@ somehow I prefer it.
             (avy-setup-default)
             (setq avy-all-windows nil
                   avy-keys '(?a ?r ?s ?t ?d ?h ?n ?e ?i ?\;))))
-#+END_SRC
+;; #+END_SRC
 
-*** ace-link
+;; **** ace-link
 
-Visit any link.  Despite the name, this works with avy.
+;; Visit any link.  Despite the name, this works with avy.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package ace-link
   :after avy
   :config (progn
@@ -2694,36 +2671,36 @@ Visit any link.  Despite the name, this works with avy.
             (with-eval-after-load "gnus"
               (bind-key "M-o" #'ace-link-gnus gnus-summary-mode-map)
               (bind-key "M-o" #'ace-link-gnus gnus-article-mode-map))))
-#+END_SRC
+;; #+END_SRC
 
-** goto-chg
+;; *** goto-chg
 
-This is like popping the mark, only it filters to only change areas
-and doesn’t go back to the same place more than once.
+;; This is like popping the mark, only it filters to only change areas
+;; and doesn’t go back to the same place more than once.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package goto-chg
   :bind ("C-c C-SPC" . goto-last-change))
-#+END_SRC
+;; #+END_SRC
 
-** beginend
+;; *** beginend
 
-In special buffers, I would rather have =M->= and =M-<= goto the
-logical beginning/end rather than the physical ones.
+;; In special buffers, I would rather have =M->= and =M-<= goto the
+;; logical beginning/end rather than the physical ones.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package beginend
   :config (progn
             (beginend-setup-all)))
-#+END_SRC
+;; #+END_SRC
 
-** multiple-cursors
+;; *** multiple-cursors
 
-I mentioned before that I’d used Sublime Text before.  Multiple
-cursors was one of my favourite features, so I was really happy when I
-saw that multiple-cursors was released for Emacs.
+;; I mentioned before that I’d used Sublime Text before.  Multiple
+;; cursors was one of my favourite features, so I was really happy when I
+;; saw that multiple-cursors was released for Emacs.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package multiple-cursors
   :defer 1
   :bind* (("C-." . mc/mark-next-like-this)
@@ -2731,14 +2708,14 @@ saw that multiple-cursors was released for Emacs.
           ("M-<f3>" . mc/mark-all-like-this-dwim)
           ("C-<f3>" . mc/mark-more-like-this-extended)
           ("C-S-L" . mc/edit-lines)))
-#+END_SRC
+;; #+END_SRC
 
-** paredit
+;; *** paredit
 
-Balanced parentheses in lisps are nice, but all the refactoring and
-movement commands are much more interesting.
+;; Balanced parentheses in lisps are nice, but all the refactoring and
+;; movement commands are much more interesting.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package paredit
   :diminish "()"
   :config (progn
@@ -2746,15 +2723,15 @@ movement commands are much more interesting.
             (put #'paredit-forward-delete 'delete-selection 'supersede)
             (put #'paredit-backward-delete 'delete-selection 'supersede)
             (add-hook 'eval-expression-minibuffer-setup-hook #'enable-paredit-mode)))
-#+END_SRC
+;; #+END_SRC
 
-** smartparens
+;; *** smartparens
 
-I like to use smartparens where paredit isn’t already useful.  Somehow
-I didn’t find smartparens’ implementation of paredit style to be as
-nice as the real version
+;; I like to use smartparens where paredit isn’t already useful.  Somehow
+;; I didn’t find smartparens’ implementation of paredit style to be as
+;; nice as the real version
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (eval-when-compile (require 'smartparens nil :noerror))
 (use-package smartparens-config
   :ensure smartparens
@@ -2774,32 +2751,30 @@ nice as the real version
             (bind-key "M-<up>" #'sp-splice-sexp-killing-backward smartparens-mode-map)
             (bind-key "M-<down>" #'sp-splice-sexp-killing-forward smartparens-mode-map)
             (bind-key "C-M-S-k" #'sp-kill-hybrid-sexp smartparens-mode-map)
-            (bind-key "C-S-<right>" #'sp-slurp-hybrid-sexp smartparens-mode-map)
-            (sp-with-modes '(twig-mode)
-              (sp-local-pair "{%" "%}")
-              (sp-local-pair "{{" "}}"))
+            (bind-key "C-S-<right>" #'sp-slurp-hybrid-sexp smartparens-mode-map) 
             (show-smartparens-global-mode t)
             (smartparens-global-strict-mode t)
-            (add-hook 'lisp-mode-common-hook #'turn-off-smartparens-mode)
-            (add-hook 'coffee-mode-hook #'turn-off-smartparens-mode)))
-#+END_SRC
+            (define-hook-helper lisp-mode-common ()
+              (smartparens-strict-mode -1)
+              (smartparens-mode -1))))
+;; #+END_SRC
 
 
-** move-text
+;; *** move-text
 
-Transposing lines, made easier.
+;; Transposing lines, made easier.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package move-text
   :config (move-text-default-bindings))
-#+END_SRC
+;; #+END_SRC
 
-** undo-tree
+;; *** undo-tree
 
-Emacs’ default handling of undo is a bit confusing.  Undo-tree makes
-it much clearer.  It’s especially helpful for protoyping and refactoring.
+;; Emacs’ default handling of undo is a bit confusing.  Undo-tree makes
+;; it much clearer.  It’s especially helpful for protoyping and refactoring.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package undo-tree
   :config (progn
             (global-undo-tree-mode)
@@ -2815,90 +2790,35 @@ it much clearer.  It’s especially helpful for protoyping and refactoring.
                     (set-marker m nil))
                 ad-do-it)))
   :diminish undo-tree-mode)
-#+END_SRC
+;; #+END_SRC
 
-** replace
+;; *** replace
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (with-eval-after-load "replace.el"
   (setq case-replace nil))
-#+END_SRC
+;; #+END_SRC
 
-** visual-regexp
+;; *** visual-regexp
 
-I don’t always remember exactly how Emacs’ regular expressions work,
-so this package is pretty useful because it highlights everything in
-the buffer for me.
+;; I don’t always remember exactly how Emacs’ regular expressions work,
+;; so this package is pretty useful because it highlights everything in
+;; the buffer for me.
 
-#+BEGIN_SRC emacs-lisp
+;; #+BEGIN_SRC emacs-lisp
 (use-package visual-regexp
   :bind (("C-c r" . vr/replace)
          ("C-c q" . vr/query-replace)
          ("C-c m" . vc/mc-mark)))
-#+END_SRC
-* Tangling
-
-Taken from [[https://github.com/larstvei/dot-emacs/blob/master/init.org][larstvei/dot-emacs]].  I changed it so that it would work with
-my current dotfiles repository structure and work asynchronously,
-thanks to [[https://github.com/jwiegley/emacs-async][jwiegley/emacs-async]].
-
-We can use =C-c C-v t= to run =org-babel-tangle=, which extracts the
-code blocks from the current file into a source-specific file (in this
-case a =.el=-file).
-
-To avoid doing this each time a change is made we can add a function
-to the =after-save-hook= ensuring to always tangle and byte-compile
-the =org=-document after changes.
+;; #+END_SRC
 
-#+BEGIN_SRC emacs-lisp
-(use-package async
-  :commands (async-start)
-  :defer 2)
+;; ** End
 
-(defun tangle-if-init ()
-  "If the current buffer is 'init.org' the code-blocks are
-    tangled, and the tangled file is compiled."
-
-  (when (string-suffix-p "init.org" (buffer-file-name))
-    (tangle-init)))
-
-(defun tangle-init-sync ()
-  (interactive)
-  (message "Tangling init")
-  ;; Avoid running hooks when tangling.
-  (let ((prog-mode-hook nil)
-        (src  (expand-file-name "init.org" user-emacs-directory))
-        (dest (expand-file-name "init.el"  user-emacs-directory)))
-    (require 'ob-tangle)
-    (org-babel-tangle-file src dest)
-    (if (byte-compile-file dest)
-        (byte-compile-dest-file dest)
-      (with-current-buffer byte-compile-log-buffer
-        (buffer-string)))))
-
-(defun tangle-init ()
-  "Tangle init.org asynchronously."
-
-  (interactive)
-  (message "Tangling init")
-  (async-start
-   (symbol-function #'tangle-init-sync)
-   (lambda (result)
-     (message "Init tangling completed: %s" result))))
-#+END_SRC
-
-# Local Variables:
-# eval: (when (fboundp #'tangle-if-init) (add-hook 'after-save-hook #'tangle-if-init))
-# End:
-* End
-
-Start a server if possible.  A daemon is already a server.
-#+BEGIN_SRC emacs-lisp
+;; Start a server if possible.  A daemon is already a server.
+;; #+BEGIN_SRC emacs-lisp
 (use-package server
   :defer 2
   :if (not (daemonp))
   :config (unless (server-running-p server-name)
             (server-start)))
-(setq gc-cons-threshold 800000
-      file-name-handler-alist file-name-handler-alist-backup)
-#+END_SRC
+;; #+END_SRC