summary refs log tree commit diff stats
diff options
context:
space:
mode:
authorAlan Pearce2017-08-07 16:50:24 +0200
committerAlan Pearce2017-08-07 16:50:24 +0200
commita240cca30cb961244331e427309b18c5ae4695d4 (patch)
tree41bcd6dbe08f4bb6a3c0588763cee68ce7ba67ae
parentbe62cbb6aa92d2f788fd9449152156076151ca1f (diff)
downloadnixfiles-a240cca30cb961244331e427309b18c5ae4695d4.tar.lz
nixfiles-a240cca30cb961244331e427309b18c5ae4695d4.tar.zst
nixfiles-a240cca30cb961244331e427309b18c5ae4695d4.zip
Emacs: Fix execution of old code at startup
Set load-prefer-newer before loading main init code (it does not apply
to the file it is in)
Set auto-compile-on-load to compile init.el if it is newer than init.elc
-rw-r--r--emacs/.emacs.d/init.el2834
-rw-r--r--emacs/.emacs.d/main.el2821
2 files changed, 2835 insertions, 2820 deletions
diff --git a/emacs/.emacs.d/init.el b/emacs/.emacs.d/init.el
index 1880871c..22c3f72c 100644
--- a/emacs/.emacs.d/init.el
+++ b/emacs/.emacs.d/init.el
@@ -1,2824 +1,18 @@
-;;; 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
+;;; init --- user init file -*- no-byte-compile: t -*-
+;;; Commentary:
+;; Entry point for Emacs init.
+;; Ensures that main init code is up-to-date by loading the newest version.
+;;
 ;;; 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)
-(add-hook 'after-init-hook
-          (lambda ()
-            (setq gc-cons-threshold 800000)))
-(remove-hook 'find-file-hooks #'vc-refresh-state)
-;; #+END_SRC
+(setq load-prefer-newer t
+      package-user-dir (concat "~/.emacs.d/packages/" emacs-version "/elpa"))
 
-;; Are we running on Windows via the WSL?
+(setq package-archives nil)
+(package-initialize)
+(require 'auto-compile nil :noerror)
 
-;; #+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
+(when (featurep 'auto-compile)
+  (auto-compile-on-load-mode))
 
-;; *** Compatibility
-
-;; #+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
-
-;; *** 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
-
-;; *** Personal Information
-;; #+BEGIN_SRC emacs-lisp
-(setq user-mail-address "alan@alanpearce.eu"
-      user-full-name "Alan Pearce")
-;; #+end_src
-
-;; ** Packaging
-
-;; *** Use-package
-
-;; #+BEGIN_SRC emacs-lisp
-(eval-and-compile
-  (require 'seq)
-  (defvar nix-emacs (and (string-match "^/nix/store" invocation-directory)
-                         (not (null (seq-some (lambda (dir) (string-match "^/nix/store" dir)) load-path)))))
-
-  (setq tls-checktrust t
-        gnutls-verify-error t
-        package-menu-async t
-        package-user-dir (concat "~/.emacs.d/packages/" emacs-version "/elpa")
-        package-menu-hide-low-priority t)
-  (if nix-emacs
-      (progn (setq package-archives nil)
-             (package-initialize))
-    (setq package-archives '(("gnu" . "https://elpa.gnu.org/packages/")
-                             ("melpa-stable" . "https://stable.melpa.org/packages/")
-                             ("melpa" . "https://melpa.org/packages/"))
-          package-pinned-packages '(("use-package" . melpa-stable)
-                                    ("diminish" . melpa-stable)
-                                    ("bind-key" . melpa-stable))
-          package-archive-priorities '(("melpa" . 10)
-                                       ("gnu" . 10)
-                                       ("melpa-stable" . 5)
-                                       ("marmalade" . 0))))
-  (when (eq system-type 'darwin)
-    (with-eval-after-load "gnutls"
-      (add-to-list 'gnutls-trustfiles "/etc/ssl/cert.pem")))
-  (unless nix-emacs
-    (package-initialize)
-    (unless (package-installed-p 'use-package)
-      (package-refresh-contents)
-      (package-install 'use-package))))
-(eval-when-compile (require 'use-package))
-(unless (featurep 'use-package)
-  (require 'diminish)
-  (require 'bind-key)
-  (use-package use-package
-    :commands (use-package-autoload-keymap)
-    :defer 5))
-(setq use-package-always-ensure (not nix-emacs)
-      use-package-always-demand (daemonp)
-      package-enable-at-startup nil)
-;; #+END_SRC
-
-;; *** Helpers
-
-;; **** Hook Helpers
-
-;; 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
-(eval-and-compile
-  (use-package hook-helpers))
-;; #+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=
-
-;; #+BEGIN_SRC emacs-lisp
-(setq custom-file "~/.emacs.d/custom.el")
-(load custom-file :noerror :nomessage)
-;; #+END_SRC
-
-;; ** Styles
-
-;; I prefer an always-visible cursor.  Feels less distracting.
-;; #+BEGIN_SRC emacs-lisp
-(when (fboundp #'blink-cursor-mode)
-  (blink-cursor-mode -1))
-;; #+END_SRC
-
-;; Disable all the bars, unless on OSX, in which case, keep the menu bar.
-
-;; #+BEGIN_SRC emacs-lisp
-(when (and menu-bar-mode (not (eq window-system 'ns)))
-  (menu-bar-mode -1))
-(with-eval-after-load 'scroll-bar
-  (set-scroll-bar-mode nil))
-(with-eval-after-load 'tooltip
-  (tooltip-mode -1))
-(with-eval-after-load 'tool-bar
-  (tool-bar-mode -1))
-;; #+END_SRC
-
-;; 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
-
-;; *** Colours
-
-;; 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
-(use-package eziam-light-theme
-  :ensure eziam-theme
-  :disabled t
-  :if (or window-system
-          (daemonp))
-  :defines (eziam-scale-headings)
-  :config (progn
-            (setq eziam-scale-headings nil)
-            (load-theme 'eziam-light t)
-            (custom-theme-set-faces 'user
-                                    '(default ((t (:background "#ffffff"))))
-                                    '(js2-function-call ((t (:underline nil))))
-                                    '(js2-object-property ((t (:slant normal))))
-                                    '(font-lock-keyword-face ((t (:weight normal))))
-                                    '(git-gutter-fr:added ((t (:foreground "#96a4ab"))))
-                                    '(git-gutter-fr:modified ((t (:foreground "#96a4ab"))))
-                                    '(git-gutter-fr:deleted ((t (:foreground "#96a4ab")))))))
-;; #+END_SRC
-
-;; White-theme.  Sounds like a good idea.
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package white-theme
-  :if (or window-system
-          (daemonp))
-  :config (progn
-            (load-theme 'white t)
-            (custom-theme-set-faces 'user
-                                    '(git-gutter-fr:added ((t (:foreground "#b8b8b8"))))
-                                    '(git-gutter-fr:modified ((t (:foreground "#b8b8b8"))))
-                                    '(git-gutter-fr:deleted ((t (:foreground "#b8b8b8"))))
-                                    '(font-lock-string-face ((t (:slant normal)))))))
-;; #+END_SRC
-
-;; Base16 theming allows me have a consistent style between applications
-;; quite easily.
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package base16-theme
-  :if (or window-system
-          (daemonp)))
-;; #+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
-(use-package highlight-stages
-  :diminish highlight-stages-mode)
-;; #+END_SRC
-
-;; *** 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 (or (display-graphic-p)
-          (daemonp))
-
-  (defun use-variable-fonts ()
-    (interactive)
-    (variable-pitch-mode)
-    (setq cursor-type '(bar . 1)))
-
-  (defun ap/set-fonts (mono-face mono-font-size variable-face variable-font-size antialias &optional new-line-spacing)
-    (if (boundp 'ns-antialias-text)
-        (setq ns-antialias-text antialias))
-    (if (boundp 'new-line-spacing)
-      (setq line-spacing new-line-spacing))
-    (when mono-face
-      (let ((default-font (font-spec :family mono-face :size  mono-font-size)))
-        (add-to-list 'default-frame-alist `(font . ,(format "%s %s" mono-face mono-font-size)))
-        (set-face-font 'fixed-pitch default-font)
-        (set-frame-font default-font t t)))
-    (when variable-face
-      (set-face-font 'variable-pitch (font-spec :name variable-face :size variable-font-size))))
-
-  (defun ap/set-fonts-according-to-system ()
-    (interactive)
-    (cond
-     ((eq window-system 'w32)
-      (ap/set-fonts "Liberation Mono" 11 "Segoe UI" 11 t))
-     ((or (eq window-system 'mac)
-          (eq window-system 'ns))
-      (let ((displays (string-to-number (shell-command-to-string "system_profiler SPDisplaysDataType | grep \"Online: Yes\" | wc -l"))))
-        (if (eq displays 1)
-            (ap/set-fonts "Fira Code" 14 "Lucida Grande" 14 t nil)
-          (ap/set-fonts "Monoid" 12 "Helvetica Neue" 12 t 0.1))))
-     ((and (eq window-system 'x)
-           (not (eq system-type 'gnu/linux/windows)))
-      (set-fontset-font "fontset-default" 'unicode (font-spec :name "PT Mono" :size 14))
-      (ap/set-fonts "PT Mono" 14 "Noto Sans" 14 nil))
-     ((and (eq window-system 'x)
-           (eq system-type 'gnu/linux/windows))
-      (ap/set-fonts "Noto Mono" 12 "Sans" 12 nil))))
-
-  (ap/set-fonts-according-to-system))
-;; #+END_SRC
-
-;; 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
-
-;; 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
-(if (eq window-system 'mac)
-    (mac-auto-operator-composition-mode +1)
-    (global-prettify-symbols-mode +1))
-;; #+END_SRC
-
-;; *** 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.
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package page-break-lines
-  :defer 5
-  :diminish page-break-lines-mode
-  :config (progn
-            (global-page-break-lines-mode)
-            (unless (eq (char-displayable-p ?─) (char-displayable-p ?a))
-              (set-fontset-font "fontset-default"
-                                (cons page-break-lines-char page-break-lines-char)
-                                (face-attribute 'default :family)))))
-;; #+END_SRC
-;; *** Modeline
-
-;; #+BEGIN_SRC emacs-lisp
-(column-number-mode -1)
-(line-number-mode -1)
-(size-indication-mode t)
-
-
-(require 'f)
-(setq frame-title-format (list "Emacs"
-                               (if (and nix-emacs invocation-directory)
-                                   (list " (Nix Generation "
-                                         (cadr
-                                          (split-string (f-base
-                                                         (car
-                                                          (last (seq-take-while
-                                                                 (lambda (s) (s-contains? "profile" s))
-                                                                 (split-string
-                                                                  (s-chomp (shell-command-to-string (concat "nix-store -q --roots " invocation-directory)))
-                                                                  "\n")))))
-                                                        "-"))
-                                         " "
-                                         (s-left 6 (nth 3 (f-split invocation-directory)))
-                                         "..."
-                                         (s-right 6 (car (split-string (nth 3 (f-split invocation-directory)) "-")))
-                                         ")"))
-                               '(buffer-file-name " — %f")
-                               '(dired-directory (" — " dired-directory))))
-;; #+END_SRC
-
-;; *** Chrome
-
-;; Sometimes I like to hide clutter.  Other times, it's useful.
-
-;; #+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")
-
-(defun show-mode-line ()
-  (interactive)
-  (setq mode-line-format mode-line-default-format)
-  (when (called-interactively-p 'interactive)
-    (setq-default mode-line-format mode-line-default-format)
-    (setq mode-line-default-hidden nil)))
-(defun hide-mode-line ()
-  (interactive)
-  (setq mode-line-format nil)
-  (when (called-interactively-p 'interactive)
-    (setq-default mode-line-format nil)
-    (setq mode-line-default-hidden t)))
-
-(setq-default cursor-in-non-selected-windows nil)
-
-(defun hide-clutter ()
-  (interactive)
-  (hide-mode-line))
-
-(defun show-clutter ()
-  (interactive)
-  (show-mode-line))
-
-(when mode-line-default-hidden
-  (call-interactively #'hide-mode-line))
-
-(setq-default indicate-buffer-boundaries nil)
-(fringe-mode '(4 . 4))
-
-(defun hide-mode-line-if-default-hidden ()
-  (if mode-line-default-hidden
-      (hide-mode-line)
-    (show-mode-line)))
-
-(add-to-list 'default-frame-alist '(border-width . 0))
-(add-to-list 'default-frame-alist '(internal-border-width . 0))
-(when (or (eq window-system 'x)
-          (eq window-system 'mac))
-  (setq window-divider-default-bottom-width 1
-        window-divider-default-right-width 1
-        window-divider-default-places t)
-  (window-divider-mode +1))
-
-(add-hook 'after-change-major-mode-hook #'hide-mode-line-if-default-hidden)
-
-(add-hook 'minibuffer-setup-hook #'show-mode-line)
-(add-hook 'minibuffer-exit-hook #'hide-mode-line)
-;; #+END_SRC
-
-;; *** Highlight Changes
-
-;; Highlight what just changed when I undo, yank, and so on.
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package volatile-highlights
-  :diminish volatile-highlights-mode
-  :config (progn
-            (volatile-highlights-mode t)))
-;; #+END_SRC
-
-;; *** 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.
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package beacon
-  :diminish beacon-mode
-  :config (progn
-            (beacon-mode +1)
-            (setq beacon-blink-delay 0.25
-                  beacon-blink-duration 0.25
-                  beacon-size 20
-                  beacon-color "#a1b56c")))
-;; #+END_SRC
-
-;; *** Renaming major modes
-
-;; Diminishing major modes does not happen in the same manner as minor
-;; modes.
-
-;; #+BEGIN_SRC emacs-lisp
-(unless (version<= emacs-version "24.4")
-  (use-package cyphejor
-    :defer 2
-    :config (progn
-              (setq cyphejor-rules `(("emacs"       "ε")
-                                     ("diff"        "Δ")
-                                     ("js2"         "js")
-                                     ("magit-status" ,(char-to-string (seq-find #'char-displayable-p '(11942 5848 177))))
-                                     ("inferior"    "i" :prefix)
-                                     ("interaction" "i" :prefix)
-                                     ("interactive" "i" :prefix)
-                                     ("menu"        "▤" :postfix)
-                                     ("ledger"      "Ledger")
-                                     ("mode"        "")
-                                     ("shell"       "sh" :postfix)))
-              (cyphejor-mode 1))))
-;; #+END_SRC
-
-
-;; ** 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.
-
-;; 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
-(use-package exec-path-from-shell
-  :if (or (eq system-type 'darwin)
-          (eq system-type 'gnu/linux/windows)
-          (and (eq system-type 'gnu/linux)
-               (daemonp)))
-  :config (progn
-            (setq exec-path-from-shell-arguments '("-l"))
-            (exec-path-from-shell-initialize)))
-;; #+END_SRC
-
-;; *** 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.
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package nix-sandbox
-  :config (progn
-            (with-eval-after-load 'flycheck
-              (setq flycheck-command-wrapper-function
-                    (lambda (command)
-                      (if (nix-current-sandbox)
-                          (apply 'nix-shell-command (nix-current-sandbox) command)
-                        command))
-                    flycheck-executable-find
-                    (lambda (cmd)
-                      (if (nix-current-sandbox)
-                          (nix-executable-find (nix-current-sandbox) cmd)
-                        (executable-find cmd)))))))
-;; #+END_SRC
-
-;; ** 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.
-
-;; #+BEGIN_SRC emacs-lisp
-(when (eq system-type 'darwin)
-  (set-keyboard-coding-system nil)
-  (custom-set-variables
-   '(mac-option-modifier 'meta)
-   '(mac-right-option-modifier 'none)
-   '(mac-control-modifier 'control)
-   '(mac-right-control-modifier 'left)
-   '(mac-command-modifier 'super)
-   '(mac-right-command-modifier 'left)
-   '(mac-function-modifier 'hyper))
-  (unbind-key "s-x"))
-;; #+END_SRC
-
-;; #+BEGIN_SRC emacs-lisp
-(unbind-key "<f4>")
-(bind-key* "<f5>" #'compile)
-(bind-key* "<f6>" #'kmacro-start-macro-or-insert-counter)
-(bind-key* "<f7>" #'kmacro-end-or-call-macro)
-
-(bind-key* "<apps>" #'execute-extended-command)
-
-(unbind-key "C-z")
-(bind-key* "C-<tab>" #'other-window)
-
-(bind-key* "C-x C-r" #'revert-buffer)
-(bind-key* "C-x C-j" #'delete-indentation)
-(unbind-key "C-x C-c")
-
-(bind-key* "C-c i" #'insert-char)
-(bind-key* "M-/" #'hippie-expand)
-
-(unbind-key "s-h")
-(unbind-key "s-n")
-(unbind-key "s-p")
-(unbind-key "s-w")
-(bind-key* "s-k" #'kill-or-delete-this-buffer-dwim)
-
-(bind-key "C-M-a" #'backward-paragraph text-mode-map)
-(bind-key "C-M-e" #'forward-paragraph text-mode-map)
-
-(bind-key* "s-x" (define-prefix-command 'super-x-map))
-(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
-
-;; *** Crux
-
-;; I can replace most of the simple helper/wrapper functions in my
-;; configuration with crux.el
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package crux
-  :bind (("M-o" . crux-smart-open-line-above)
-         ("C-o" . crux-smart-open-line)
-
-         ("C-x 4 t" . crux-transpose-windows)
-         ("C-c e" . crux-eval-and-replace)
-         ("C-c D" . crux-delete-file-and-buffer)
-         ("C-c R" . crux-rename-file-and-buffer))
-  :config (progn
-            (crux-reopen-as-root-mode +1))
-  :init (progn
-          (defalias 'delete-current-buffer-file #'crux-delete-file-and-buffer)
-          (defalias 'rename-current-buffer-file #'crux-rename-file-and-buffer)))
-;; #+END_SRC
-
-;; ** Projects
-
-;; #+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
-
-;; *** The Silver Searcher
-
-;; #+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
-
-;; *** Ripgrep
-
-;; Step over Silver Search, here comes a new challenger.
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package ripgrep
-  :if (executable-find "rg"))
-
-(use-package projectile-ripgrep
-  :after (ripgrep projectile)
-  :if (executable-find "rg")
-  :bind (("C-c p s r" . projectile-ripgrep)))
-;; #+END_SRC
-
-;; *** Projectile
-
-;; Projectile is awesome for working in projects, especially VCS-backed
-;; ones.
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package projectile
-  :bind (("s-p" . projectile-switch-project)
-         ("C-c C-f" . projectile-find-file)
-         ("s-x s-f" . projectile-find-file)
-         ("C-x g" . projectile-vc)
-         ("s-G"   . projectile-vc))
-  :demand t
-  :diminish projectile-mode
-  :config (progn
-            (projectile-mode +1)
-            (add-to-list 'projectile-globally-ignored-directories ".stversions")
-
-            (defun yarn-install (&optional arg)
-              (interactive "P")
-              (projectile-with-default-dir (projectile-project-root)
-                (cmd-to-echo "yarn" "install")))
-
-            (defun yarn-add-dev (package)
-              (interactive "spackage: ")
-              (projectile-with-default-dir (projectile-project-root)
-                (cmd-to-echo "yarn" (concat "add --dev " package))))
-
-            (defun yarn-add (package)
-              (interactive "spackage: ")
-              (projectile-with-default-dir (projectile-project-root)
-                (cmd-to-echo "yarn" (concat "add " package))))
-
-            (defun yarn-run (cmd)
-              (interactive (list
-                            (projectile-completing-read "command: " (alist-get 'scripts (json-read-file (expand-file-name "package.json" (projectile-project-root)))))))
-              (projectile-with-default-dir (projectile-project-root)
-                (cmd-to-echo "yarn" (concat "run " cmd))))
-
-            (defun ap/open-project (&optional arg)
-              (interactive "P")
-              (let ((project-dir (projectile-completing-read
-                                  "Open project: "
-                                  (ghq--find-projects))))
-                (projectile-switch-project-by-name
-                 (expand-file-name project-dir (ghq--find-root)) arg)))
-
-            (setq projectile-switch-project-action #'projectile-commander
-                  projectile-completion-system 'ivy
-                  projectile-create-missing-test-files t)
-
-            (defun ap/projectile-test-suffix (project-type)
-              (cond
-               ((member project-type '(node-yarn node-npm)) ".test")
-               (t (projectile-test-suffix project-type))))
-            (setq projectile-test-suffix-function #'ap/projectile-test-suffix)
-
-            (projectile-register-project-type 'node-yarn '("yarn.lock") "yarn start" "yarn test")
-            (projectile-register-project-type 'node '("package.json") "npm start" "npm test")))
-
-(use-package counsel-projectile
-  :after (counsel projectile)
-  :config (progn
-            (counsel-projectile-on)
-            (def-projectile-commander-method ?A
-              "Find rg on project."
-              (call-interactively #'counsel-projectile-rg))
-            (define-key projectile-mode-map [remap counsel-projectile-ag] #'counsel-projectile-rg)))
-;; #+END_SRC
-
-;; *** 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.
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package vc
-  :defer t
-  :bind (("C-x v C" . vc-resolve-conflicts))
-  :config (progn
-            (setq vc-follow-symlinks t)
-            (setq vc-ignore-dir-regexp (format "\\(%s\\)\\|\\(%s\\)"
-                                               vc-ignore-dir-regexp
-                                               tramp-file-name-regexp))))
-;; #+END_SRC
-
-;; *** 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.
-
-;; #+BEGIN_SRC emacs-lisp
-(eval-when-compile (require 'fringe-helper))
-(use-package git-gutter-fringe
-  :defer 2
-  :diminish git-gutter-mode
-  :config (progn
-            (global-git-gutter-mode 1)
-            ;; places the git gutter outside the margins.
-            (setq-default fringes-outside-margins t)
-            ;; thin fringe bitmaps
-            (fringe-helper-define 'git-gutter-fr:added '(center repeated)
-              ".XXX....")
-            (fringe-helper-define 'git-gutter-fr:modified '(center repeated)
-              ".XXX....")
-            (fringe-helper-define 'git-gutter-fr:deleted 'bottom
-              ".......X"
-              "......XX"
-              ".....XXX"
-              "....XXXX")
-            (setq git-gutter-fr:side 'right-fringe)))
-;; #+END_SRC
-
-;; *** 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=
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package magit
-  :defer 5
-  :commands (magit-status)
-  :config (progn (setq magit-completing-read-function #'ivy-completing-read
-                       magit-popup-use-prefix-argument 'default
-                       magit-display-buffer-function #'magit-display-buffer-fullcolumn-most-v1
-                       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
-
-;; *** git-messenger
-
-;; Popup the last commit that changed the line at point.
-
-;; #+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
-
-;; *** 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.
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package git-timemachine
-  :commands git-timemachine)
-;; #+END_SRC
-
-;; *** 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.
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package ghq
-  :if (executable-find "ghq"))
-;; #+END_SRC
-
-;; ** Files
-
-;; *** Auto-saving
-
-;; Auto-save everything to a temporary directory, instead of cluttering
-;; the filesystem.  I don’t want emacs-specific lockfiles, either.
-
-;; #+BEGIN_SRC emacs-lisp
-(setq auto-save-file-name-transforms `((".*" ,temporary-file-directory t))
-      create-lockfiles nil)
-;; #+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
-(let ((backup-dir (expand-file-name "~/.emacs.d/backups/")))
-  (unless (file-directory-p backup-dir)
-    (make-directory backup-dir))
-  (setq backup-directory-alist `((".*" . ,backup-dir))
-        backup-by-copying-when-linked t
-        backup-by-copying-when-mismatch t))
-(if (eq system-type 'darwin)
-    (setq delete-by-moving-to-trash t)
-  (if (and (executable-find "trash") (not (fboundp #'system-move-file-to-trash)))
-      (defun system-move-file-to-trash (file)
-        (call-process (executable-find "trash")
-                      nil 0 nil
-                      file))))
-;; #+END_SRC
-
-;; *** autorevert
-
-;; #+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
-
-;; *** Encoding
-
-;; 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
-(prefer-coding-system 'utf-8)
-(setq-default buffer-file-coding-system 'utf-8-auto-unix)
-;; #+END_SRC
-
-;; *** Buffer-file management
-
-;; 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
-(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
-
-;; I often want to rename or delete the file that I’m currently visiting
-;; with a buffer.
-
-;; #+BEGIN_SRC emacs-lisp
-(defun kill-or-delete-this-buffer-dwim (&optional arg)
-  "Kills current buffer.  With prefix arg, delete it."
-  (interactive "P")
-  (if (equal arg '(4))
-      (delete-current-buffer-file)
-    (if server-buffer-clients
-        (server-edit)
-      (let ((buf (buffer-name)))
-        (when (equal buf "*HTTP Response*")
-          (other-window 1))
-        (kill-buffer buf)))))
-;; #+END_SRC
-
-;; *** Whitespace
-
-;; Show bad whitespace, so that I can fix it.
-
-;; #+BEGIN_SRC emacs-lisp
-(defun show-trailing-whitespace-on ()
-  (interactive)
-  (setq-local show-trailing-whitespace t))
-(defun show-trailing-whitespace-off ()
-  (interactive)
-  (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
-
-;; *** shrink-whitespace
-
-;; DWIM whitespace removal.  So I don’t need =M-SPC=, =M-\= and =C-x o=
-;; for similar things any more.
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package shrink-whitespace
-  :bind ("M-SPC" . shrink-whitespace))
-;; #+END_SRC
-
-;; *** Tramp
-
-;; 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
-(use-package tramp
-  :defer 7
-  :config (progn
-            (unless (getenv "SSH_AUTH_SOCK")
-              (setenv "SSH_AUTH_SOCK" (format "/run/user/%s/ssh-agent" (user-uid))))
-            (setq tramp-default-method "ssh"
-                  tramp-default-user-alist '(("\\`su\\(do\\)?\\'" nil "root"))
-                  tramp-backup-directory-alist backup-directory-alist
-                  tramp-completion-reread-directory-timeout 60
-                  tramp-ssh-controlmaster-options nil
-                  backup-enable-predicate (lambda (name)
-                                            (and (normal-backup-enable-predicate name)
-                                                 (not (let ((method (file-remote-p name 'method)))
-                                                        (when (stringp method)
-                                                          (member method '("su" "sudo")))))))
-                  tramp-shell-prompt-pattern "\\(?:^\\|
\\)[^]#$%>\n]*#?[]#$%>❯›] *\\(\\[\\??[0-9;]*[a-zA-Z] *\\)*")
-            (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
-
-;; *** ediff
-
-;; I like a horizonal diff setup, with everything in one frame.
-
-;; #+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
-
-;; ** 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.
-
-;; #+BEGIN_SRC emacs-lisp
-(setq-default tab-width 2
-              indent-tabs-mode nil)
-(electric-indent-mode +1)
-;; #+END_SRC
-
-
-;; *** smart-tabs-mode
-
-;; Not related to [[smart-tab][=smart-tab=]], this mode indents with tabs and aligns
-;; with spaces.  Perfect!
-
-;; #+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
-
-;; *** editorconfig
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package editorconfig
-  :diminish "EC"
-  :config (editorconfig-mode 1))
-;; #+END_SRC
-
-;; *** dtrt-indent-mode
-
-;; Sometimes people use different indentation settings.  [[https://github.com/jscheid/dtrt-indent][dtrt-indent]]
-;; guesses the correct settings for me.
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package dtrt-indent
-  :config (progn
-            (define-hook-helper after-change-major-mode ()
-              (unless (and (boundp editorconfig-mode)
-                           editorconfig-mode)
-                (dtrt-indent-adapt)))
-            (defadvice dtrt-indent-try-set-offset (after toggle-smart-tabs activate)
-              (smart-tabs-mode (or indent-tabs-mode -1)))))
-;; #+END_SRC
-
-;; ** Security
-
-;; *** password-store
-
-;; 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
-
-;; *** Ibuffer
-;; Ibuffer is quite nice for listing all buffers.
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package ibuffer
-  :bind (("C-x C-b" . ibuffer))
-  :config (progn
-            (setq ibuffer-saved-filter-groups
-                  (quote (("default"
-                           ("org" (mode . org-mode))
-                           ("emacs" (mode . emacs-lisp-mode))
-                           ("zsh" (filename . "/zsh"))
-                           ("server" (filename . "/su:root@server"))))))
-
-            ;; Human-readable base-2 size column
-            (define-ibuffer-column size-h
-              (:name "Size" :inline t)
-              (cond
-               ((> (buffer-size) 1024)
-                (format "%7.2fK" (/ (buffer-size) 1024.0)))
-               ((> (buffer-size) 1048576)
-                (format "%7.2fM" (/ (buffer-size) 1048576.0)))
-               (t
-                (format "%8d" (buffer-size)))))
-
-            (setq ibuffer-formats
-                  '((mark modified read-only " "
-                          (name 18 18 :left :elide)
-                          " "
-                          (size-h 9 -1 :right)
-                          " "
-                          (mode 16 16 :left :elide)
-                          " "
-                          filename-and-process)))))
-;; #+END_SRC
-
-;; *** Relative Buffer names
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package relative-buffers
-  :defer 15
-  :config (progn
-            (global-relative-buffers-mode)))
-;; #+END_SRC
-;; *** Narrowing
-
-;; Enable it without prompting
-
-;; #+BEGIN_SRC emacs-lisp
-(put 'narrow-to-defun  'disabled nil)
-(put 'narrow-to-page   'disabled nil)
-(put 'narrow-to-region 'disabled nil)
-;; #+END_SRC
-
-;; *** 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
-(use-package ace-window
-  :bind (("s-s" . ace-window))
-  :config (progn
-            (setq aw-dispatch-always t
-                  aw-dispatch-alist '((?k aw-delete-window " Ace - Delete Window")
-                                      (?K aw-delete-window)
-                                      (?m aw-swap-window " Ace - Swap Window")
-                                      (?f aw-flip-window)
-                                      (?v aw-split-window-vert " Ace - Split Vert Window")
-                                      (?b aw-split-window-horz " Ace - Split Horz Window")
-                                      (?m delete-other-windows " Ace - Maximize Window")
-                                      (?l delete-other-windows)
-                                      (?, winner-undo)
-                                      (?. winner-redo))
-                  aw-keys '(?a ?r ?s ?t ?n ?e ?i ?o))))
-;; #+END_SRC
-
-;; ** Windows
-
-;; Scrolling is tricky.  I use this setup to help me keep track of the
-;; point whilst I’m moving about.
-
-;; #+BEGIN_SRC emacs-lisp
-(setq scroll-conservatively 100
-      scroll-margin 1
-      scroll-preserve-screen-position t
-      mouse-wheel-scroll-amount '(1 ((shift) . 1) ((control)))
-      split-height-threshold 80
-      split-width-threshold 160
-      frame-resize-pixelwise nil)
-(if (boundp 'ns-pop-up-frames)
-    (setq ns-pop-up-frames nil))
-;; #+END_SRC
-
-;; *** 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.
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package eyebrowse
-  :config (progn
-            (setq eyebrowse-new-workspace t)
-            (when (eq system-type 'darwin)
-              (bind-keys
-               ("s-0" . eyebrowse-switch-to-window-config-0)
-               ("s-1" . eyebrowse-switch-to-window-config-1)
-               ("s-2" . eyebrowse-switch-to-window-config-2)
-               ("s-3" . eyebrowse-switch-to-window-config-3)
-               ("s-4" . eyebrowse-switch-to-window-config-4)
-               ("s-5" . eyebrowse-switch-to-window-config-5)
-               ("s-6" . eyebrowse-switch-to-window-config-6)
-               ("s-7" . eyebrowse-switch-to-window-config-7)
-               ("s-8" . eyebrowse-switch-to-window-config-8)
-               ("s-9" . eyebrowse-switch-to-window-config-9)))
-            (bind-keys*
-             ("M-0" . eyebrowse-switch-to-window-config-0)
-             ("M-1" . eyebrowse-switch-to-window-config-1)
-             ("M-2" . eyebrowse-switch-to-window-config-2)
-             ("M-3" . eyebrowse-switch-to-window-config-3)
-             ("M-4" . eyebrowse-switch-to-window-config-4)
-             ("M-5" . eyebrowse-switch-to-window-config-5)
-             ("M-6" . eyebrowse-switch-to-window-config-6)
-             ("M-7" . eyebrowse-switch-to-window-config-7)
-             ("M-8" . eyebrowse-switch-to-window-config-8)
-             ("M-9" . eyebrowse-switch-to-window-config-9))
-            (eyebrowse-mode +1)))
-;; #+END_SRC
-
-;; ** Sessions
-
-;; *** Desktop
-;; Save my Emacs session and restore it on startup.
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package desktop
-  :ensure nil
-  :config (progn
-            (setq desktop-dirname (expand-file-name "desktop/" user-emacs-directory)
-                  desktop-base-file-name "emacs.desktop"
-                  desktop-base-lock-name "lock"
-                  desktop-path (list desktop-dirname)
-                  desktop-save 'if-exists
-                  desktop-files-not-to-save "^$"
-                  desktop-load-locked-desktop nil)
-            (unless (file-directory-p desktop-dirname)
-              (make-directory desktop-dirname))
-            (desktop-save-mode 1)))
-;; #+END_SRC
-
-;; *** winner
-
-;; Undo, for window-based commands.
-
-;; #+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
-
-;; *** windmove
-
-;; Directional window movement
-
-;; #+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
-
-;; I have a [[https://alanpearce.uk][blog]] that I publish with hugo.
-
-;; #+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
-
-;; ** Completion
-
-;; Make built-in completion a bit more intelligent, by adding substring
-;; and initial-based completion and ignoring case.
-
-;; #+BEGIN_SRC emacs-lisp
-(setq completion-styles '(basic initials partial-completion substring)
-      completion-ignore-case t
-      tab-always-indent 'complete)
-;; #+END_SRC
-
-;; *** 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.
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package company
-  :commands (company-mode)
-  :diminish "Cmpl"
-  :bind (("C-<tab>" . company-complete)
-         ("TAB" . company-indent-or-complete-common))
-  :init (progn
-          (add-hook 'prog-mode-hook #'company-mode-on)
-          (setq company-backends '(company-bbdb company-web-html company-tern company-nxml company-css company-eclim company-semantic company-elisp
-                                                company-clang company-xcode company-cmake company-capf
-                                                company-files (company-gtags
-                                                               company-etags company-keywords) company-oddmuse)
-                company-frontends '(company-pseudo-tooltip-unless-just-one-frontend
-                                    company-preview-frontend
-                                    company-echo-metadata-frontend)
-                company-idle-delay .3
-                company-begin-commands '(self-insert-command)
-                company-auto-complete #'company-explicit-action-p
-                company-auto-complete-chars '(?\ ?\( ?\) ?.)
-                company-tooltip-align-annotations t
-                company-selection-wrap-around t)))
-;; #+END_SRC
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package company-web
-  :after company)
-;; #+END_SRC
-
-;;; ** Dates & Times
-
-;; *** Calendar
-
-;; 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
-
-;; 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."
-  (interactive "P")
-  (let ((format (cond
-                 ((not prefix) "%Y-%m-%d")
-                 ((equal prefix '(4)) "%d/%m/%Y")
-                 ((equal prefix '(16)) "%A, %d %B %Y"))))
-    (insert (format-time-string format))))
-
-(defun insert-datetime (prefix)
-  "Insert the current date and time."
-  (interactive "P")
-  (let ((format (cond
-                 ((not prefix) "%Y-%m-%d %H:%M:%S")
-                 ((equal prefix '(4)) "%Y-%m-%dT%H:%M:%SZ"))))
-    (insert (format-time-string format))))
-;; #+END_SRC
-
-;; #+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
-
-;; ** 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.
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package dired
-  :defer 3
-  :ensure nil
-  :config (progn
-            (bind-key "<return>" #'dired-find-file dired-mode-map)
-            (bind-key "^" (lambda () (interactive) (find-alternate-file "..")) dired-mode-map)
-            (setq dired-dwim-target t
-                  dired-recursive-copies 'top
-                  dired-recursive-deletes (if delete-by-moving-to-trash
-                                              'always
-                                              'top)
-                  dired-listing-switches "-alh")
-            (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
-
-;; Don’t show uninteresting files in dired listings.
-
-;; #+BEGIN_SRC emacs-lisp
-(defun turn-on-dired-omit-mode ()
-  (interactive)
-  (dired-omit-mode 1))
-
-(use-package dired-x
-  :commands (dired-omit-mode
-             dired-expunge)
-  :ensure nil
-  :config (progn
-            (setq dired-omit-files "#\\|\\.$"
-                  dired-omit-verbose nil
-                  dired-find-subdir t
-                  dired-bind-jump nil))
-  :init (progn
-          (add-hook 'dired-mode-hook #'turn-on-dired-omit-mode)))
-;; #+END_SRC
-
-;; Expand subfolders like a tree inside the parent
-
-;; #+BEGIN_SRC emacs-lisp
-(with-eval-after-load 'dired
-  (use-package dired-subtree
-    :functions (dired-subtree--get-ov
-                dired-subtree-maybe-up)
-    :init (progn
-            (setq dired-subtree-use-backgrounds nil)
-            (defun dired-subtree-maybe-up ()
-              "Jump up one subtree or directory"
-              (interactive)
-              (let ((ov (dired-subtree--get-ov)))
-                (if ov
-                    (progn (goto-char (overlay-start ov))
-                           (dired-previous-line 1))
-                  (dired-up-directory))))
-            (bind-key "^" #'dired-subtree-maybe-up dired-mode-map)
-            (bind-key "i" #'dired-subtree-toggle dired-mode-map))))
-;; #+END_SRC
-
-;; *** Disk usage
-
-;; Combine dired and du (disk usage).
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package dired-du
-  :after dired
-  :config (progn
-            (setq dired-du-size-format t)))
-;; #+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.
-
-;; #+BEGIN_SRC emacs-lisp
-(with-eval-after-load 'dired
-  (use-package dired-narrow
-    :bind (:map dired-mode-map
-                ("/" . dired-narrow))))
-;; #+END_SRC
-
-;; ** Documentation
-
-;; *** 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.
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package ehelp
-  :bind-keymap ("C-h" . ehelp-map))
-;; #+END_SRC
-
-;; *** discover-my-major
-
-;; A nicer way to browse keybindings for major modes.
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package discover-my-major
-  :bind ("<f1>" . discover-my-major))
-;; #+END_SRC
-
-;; *** which-key
-
-;; Popup keybindings following a prefix automatically.
-
-;; #+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
-
-;; *** eldoc
-
-;; Documentation in the echo-area (where the minibuffer is displayed) is
-;; rather useful.
-
-;; #+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
-
-;; *** 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.
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package gnus
-  :config (progn
-            (setq gnus-gcc-mark-as-read t
-                  mml-secure-openpgp-encrypt-to-self t
-                  send-mail-function #'smtpmail-send-it
-                  message-send-mail-function #'smtpmail-send-it)))
-
-(with-eval-after-load "gnus-mime"
-  (define-key gnus-mime-button-map " " #'gnus-mime-view-part-externally))
-
-(with-eval-after-load "mailcap"
-  (when (eq system-type 'darwin)
-    (mailcap-add-mailcap-entry "application" "pdf" '((viewer . "/usr/bin/qlmanage -p %s") (type . "application/pdf")))))
-
-(with-eval-after-load "mm-decode"
-  (add-to-list 'mm-discouraged-alternatives "text/html")
-  (add-to-list 'mm-discouraged-alternatives "text/richtext"))
-;; #+END_SRC
-
-;; *** BBDB
-
-;; As I'm using Emacs for email, it makes sense to have contact
-;; information here as well.
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package bbdb
-  :config (progn
-            (bbdb-initialize 'gnus 'message 'pgp)
-            (bbdb-mua-auto-update-init 'gnus 'message)
-            (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
-
-;; ** Misc
-
-;; #+BEGIN_SRC emacs-lisp
-(defvar *init-file*
-  (file-truename user-init-file)
-  "Where the emacs init file really is, passing through symlinks.")
-(set-register ?e `(file . ,*init-file*))
-
-(defun ap/remove-extra-cr ()
-  "Remove extraneous CR codes from a file"
-  (interactive)
-  (save-excursion
-    (goto-char (point-min))
-    (while (search-forward "
-  " nil t)
-      (replace-match ""))))
-
-(use-package rect
-  :ensure nil
-  :init (defun copy-rectangle (start end)
-          "Copy the region-rectangle."
-          (interactive "r")
-          (setq killed-rectangle (extract-rectangle start end))))
-
-(defun shell-execute (to-current-buffer)
-  (interactive "P")
-  (let ((file-buffer (if (buffer-file-name)
-                         (file-name-nondirectory (buffer-file-name))
-                       ""))
-        (command (read-shell-command "Shell command: " nil nil nil)))
-    (shell-command (replace-regexp-in-string "%" file-buffer command) to-current-buffer)))
-
-(defun process-exit-code (program &rest args)
-  "Run PROGRAM with ARGS and return the exit code"
-  (apply 'call-process program nil nil nil args))
-
-(defun narrow-to-region-indirect (start end)
-  "Restrict editing in this buffer to the current region, indirectly."
-  (interactive "r")
-  (deactivate-mark)
-  (let ((buf (clone-indirect-buffer nil nil)))
-    (with-current-buffer buf
-      (narrow-to-region start end))
-    (switch-to-buffer buf)))
-
-(bind-key* "M-!" #'shell-execute)
-(bind-key* "C-x r M-w" #'copy-rectangle)
-;; #+END_SRC
-
-;; *** Auxillary Configuration
-
-;; #+BEGIN_SRC emacs-lisp
-(require 'pinentry)
-
-(defvar have-private-key
-  (file-exists-p (expand-file-name "secring.gpg" "~/.gnupg/")))
-
-(defvar gpg-agent-ssh-sock
-  (or (getenv "GPG_AGENT_INFO")
-      (concat "/run/user/" (number-to-string (user-uid)) "/gnupg/S.gpg-agent.ssh")))
-
-(defun read-gpg-file (file)
-  (let ((file-to-decrypt (expand-file-name file user-emacs-directory))
-	(ctx (epg-make-context epa-protocol)))
-    (if (file-exists-p file-to-decrypt)
-	(epg-decrypt-file ctx file-to-decrypt nil)
-      (message "Decrypting %s...failed" file-to-decrypt)
-      (error "File %s does not exist" file-to-decrypt))))
-
-(defun load-gpg (file)
-  (if have-private-key
-      (load file)
-    (message "WARNING: Couldn't load %s (No gpg key found)" file)))
-
-; load this in a post-frame hook because gpg-agent asks for a password on first
-; startup and caches it. Don't want emacs daemon to hang because of gpg-agent.
-(defun load-private-data ()
-  (interactive)
-  (if (not (file-exists-p (expand-file-name (concat (system-name) ".el.gpg") user-emacs-directory)))
-      (message "No encrypted configuration matches system name `%s'" (system-name))
-    (if (not have-private-key)
-        (message "ERROR: Private GPG key not found")
-      (unless (or (getenv "GPG_AGENT_INFO")
-                  (getenv "SSH_AUTH_SOCK"))
-        (start-process "gpg-agent" nil "gpg-agent" "--daemon")
-        (setenv "SSH_AUTH_SOCK" gpg-agent-ssh-sock))
-      (setq password-cache-expiry nil)
-      (unless (file-exists-p (concat pinentry--socket-dir "pinentry"))
-        (pinentry-start)
-        (add-hook 'kill-emacs-hook 'pinentry-stop))
-      (add-to-list 'load-suffixes ".el.gpg")
-      (load-gpg (expand-file-name (system-name) user-emacs-directory)))))
-
-(defun first-frame-hook (frame)
-  (remove-hook 'after-make-frame-functions #'first-frame-hook)
-  (run-at-time nil nil 'load-private-data))
-
-(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
-
-;; ** 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.
-
-;; #+BEGIN_SRC emacs-lisp
-(setq enable-recursive-minibuffers t)
-(minibuffer-depth-indicate-mode t)
-;; #+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
-(setq minibuffer-prompt-properties '(read-only t point-entered minibuffer-avoid-prompt face minibuffer-prompt))
-;; #+END_SRC
-
-;; 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
-
-;; *** swiper/ivy
-
-;; Ivy is the new kid on the completion block.  It seems to be a strong
-;; replacement for helm so far.
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package swiper
-  :bind (("C-s" . swiper)
-         ("C-r" . swiper)
-         ("C-=" . swiper))
-  :diminish ivy-mode
-  :demand t
-  :config (progn
-            (ivy-mode 1)
-            (setq ivy-re-builders-alist '((t . ivy--regex-plus))
-                  ivy-extra-directories '("./"))
-            (ivy-set-actions 'ivy-switch-buffer '(("k" (lambda (x)
-                                                         (kill-buffer x)
-                                                         (ivy--reset-state ivy-last))
-                                                   "kill")))
-            (add-to-list 'ivy-initial-inputs-alist '(counsel-M-x . ""))))
-;; #+END_SRC
-
-;; *** counsel
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package counsel
-  :config (progn
-            (bind-key "M-x" #'counsel-M-x)
-            (bind-key "<apps>" #'counsel-M-x)
-            (bind-key "<menu>" #'counsel-M-x)
-            (bind-key "C-c M-x" #'execute-extended-command)
-            (bind-key "C-x C-f" #'counsel-find-file)
-            (bind-key "M-y" #'counsel-yank-pop)
-            (bind-key "C-x i" #'counsel-imenu)
-            (bind-key "M-y" #'ivy-next-line ivy-minibuffer-map)
-            (defadvice counsel-find-file (after find-file-sudo activate)
-              "Find file as root if necessary."
-              (when (and buffer-file-name
-                         (not (file-writable-p buffer-file-name)))
-                (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
-
-
-;; *** 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.
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package smex
-  :commands (smex
-             smex-update
-             smex-initialize)
-  :config (progn
-            (setq smex-key-advice-ignore-menu-bar t
-                  smex-auto-update nil)
-            (defun smex-update-after-load (_unused)
-              (if (boundp 'smex-cache)
-                  (smex-update)))
-            (add-hook 'after-load-functions 'smex-update-after-load))
-  :init (progn
-          (setq smex-history-length 100
-                smex-save-file (concat user-emacs-directory
-                                       "smex-items"))))
-;; #+END_SRC
-
-;; *** 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.
-
-;; #+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
-
-;; 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
-
-;; =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
-
-;; 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)))
-
-(use-package dockerfile-mode
-  :mode (("Dockerfile\\'" . dockerfile-mode)))
-
-(use-package nix-mode
-  :mode (("\\.nix\\'" . nix-mode)))
-
-(define-derived-mode xmonad-mode haskell-mode "XM")
-(add-to-list 'auto-mode-alist '("xmobarrc\\'" . xmonad-mode))
-(add-to-list 'auto-mode-alist '("xmonad.hs\\'" . xmonad-mode))
-
-(use-package nginx-mode
-  :defer t
-  :mode (("/nginx/servers/" . nginx-mode)
-         ("/nginx/.*\\.d/" . nginx-mode)))
-
-(use-package lua-mode
-  :defer t)
-
-(use-package ruby-mode
-  :mode (("\\.rb\\'" . ruby-mode)
-         ("\\.cap\\'" . ruby-mode)))
-
-(use-package go-mode
-  :mode (("\\.go\\'" . go-mode)))
-
-(use-package jinja2-mode
-  :mode (("\\.j2\\'" . jinja2-mode)
-         ("\\.jinja\\'" . jinja2-mode)))
-
-(use-package scss-mode
-  :defer t
-  :config (progn
-            (setq scss-compile-at-save nil)))
-
-(use-package toml-mode
-  :mode ("\\.toml\\'" . toml-mode))
-
-(use-package yaml-mode
-  :mode (("/group_vars/.*" . yaml-mode)
-         ("/host_vars/.*" . yaml-mode)))
-
-(define-derived-mode ansible-mode yaml-mode "Ansible")
-(add-to-list 'auto-mode-alist '("\\(?:ansible.+\\|roles/.+/\\(?:tasks\\|handlers\\)\\)/.+\\.yml\\'" . ansible-mode))
-
-(define-derived-mode saltstack-mode yaml-mode "Salt")
-(add-to-list 'auto-mode-alist '("\\.sls\\'" . saltstack-mode))
-;; #+END_SRC
-
-;; *** ledger
-
-;; I use [[http://ledger-cli.org/][=ledger=]] to manage my finances.  It has an Emacs mode, which
-;; works really nicely.
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package ledger-mode
-  :mode ("\\.ledger\\'" . ledger-mode)
-  :functions ledger-report
-  :init (progn
-          (defun open-budget ()
-            (interactive)
-            (projectile-switch-project-by-name "~/Sync/Default")
-            (find-file (expand-file-name "ledger/my.ledger" (projectile-project-root)))
-            (ledger-report "Budget (Cumulative)" nil)))
-  :config (progn
-            (setq ledger-use-iso-dates t
-                  ledger-post-use-completion-engine :ido
-                  ledger-reconcile-default-commodity "€"
-                  ledger-clear-whole-transactions t
-                  ledger-narrow-on-reconcile t
-                  ledger-reports `(("Monthly Expenses" "ledger -f %(ledger-file) reg -M \\^Flex --real -X EUR -l \"payee != 'Opening Balances'\"")
-                                   ("Average Monthly Expenses (Past 12 Months)" ,(concat "ledger -f %(ledger-file) -b "
-                                                                                    (format-time-string "%Y-%m" (time-add (current-time) (days-to-time -365)))
-                                                                                    " --monthly --average balance ^Flex"))
-                                   ("Expenses:This Month" "ledger -f %(ledger-file) bal \\^Flex -p \"this month\"")
-                                   ("On-budget Balances" "ledger -f %(ledger-file) bal --current -R :Budget: Assets:Receivable Liabilities:Personal")
-                                   ("All Account Balances" "ledger -f %(ledger-file) bal --current -R \\^Assets \\^Liabilities")
-                                   ("Budget Values (Current Month)" "ledger -f %(ledger-file) bal -p \"this month\" --limit \"payee=~/budget/\" \\^Funds")
-                                   ("Budget (Cumulative)" "ledger -f %(ledger-file) bal -E \\^Funds \\^Assets:Budget$")
-                                   ("Budget Allocation" "ledger -f %(ledger-file) bal -p \"this month\" --limit \"payee=~/budget/\" \\^Funds --format \"\\
-                    %-17((depth_spacer)+(partial_account))\\
-                    %10(percent(market(display_total), market(parent.total)))\\
-                    %16(market(display_total))\n%/\"")
-                                   ("bal" "ledger -f %(ledger-file) bal")
-                                   ("reg" "ledger -f %(ledger-file) reg")
-                                   ("equity" "ledger -f %(ledger-file) equity")
-                                   ("payee" "ledger -f %(ledger-file) reg @%(payee)")
-                                   ("account" "ledger -f %(ledger-file) reg %(account)")))))
-;; #+END_SRC
-
-;; *** Markdown
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package markdown-mode
-  :defer t
-  :config (progn
-            (add-hook 'markdown-mode-hook #'turn-on-auto-fill)))
-;; #+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-ified source code.  I think this might work better than
-;; lentic-mode, whilst also being more general.
-
-;; #+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
-(use-package org
-  :bind (("C-c C-a" . org-agenda-list)
-         ("C-c a" . org-agenda)
-         ("C-c l" . org-store-link))
-  :defer 8
-  :init (setq org-replace-disputed-keys t
-              org-ellipsis "…")
-  :config (progn
-            (setq org-directory "~/Sync/org"
-                  org-agenda-files `(,(concat org-directory "/agenda"))
-
-                  org-default-notes-file (concat org-directory "/notes")
-
-                  ;; ‘Remember’: new items at top
-                  org-reverse-note-order t
-
-                  org-modules '(org-protocol)
-
-                  ;; Add time done to ‘done’ tasks
-                  org-log-done 'time
-
-                  org-list-allow-alphabetical t
-
-                  org-adapt-indentation nil
-
-                  org-pretty-entities t
-
-                  org-table-duration-custom-format 'seconds
-
-                  org-src-fontify-natively nil
-
-                  org-export-have-math t
-
-                  org-blank-before-new-entry '((heading . t)
-                                               (plain-list-item . auto))
-                  org-fontify-done-headline t
-
-                  org-goto-interface 'outline-path-completion
-
-                  org-outline-path-complete-in-steps nil
-
-                  org-todo-keywords '((sequence "BACKLOG(b)" "TODO(t)" "WAIT(w@/!)" "STARTED(s!)" "|" "DONE(d!)")
-                                      (sequence "|" "CANCELLED(c@)"))
-                  org-log-into-drawer "LOGBOOK")
-            (set-register ?o `(file . ,(expand-file-name "organiser.org" org-directory)))
-            (add-hook 'org-mode-hook #'turn-on-auto-fill)
-            (org-load-modules-maybe t)))
-
-(use-package org-src
-  :ensure nil
-  :after org
-  :config (progn
-            (bind-key "C-x C-s" #'org-edit-src-exit org-src-mode-map)))
-;; #+END_SRC
-
-;; ***** 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.
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package ob-core
-  :defer t
-  :ensure nil
-  :config (progn
-            (org-babel-do-load-languages 'org-babel-load-languages
-                                         '((ledger . t)
-                                           (sh . t)))
-            (setq org-src-tab-acts-natively t
-                  org-edit-src-content-indentation 0
-                  org-src-preserve-indentation t)))
-;; #+END_SRC
-
-;; ***** org-journal
-
-;; I can use this to keep a journal.  I should use it.
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package org-journal
-  :bind ("s-j" . org-journal-new-entry)
-  :defer 20
-  :config (progn
-            (setq org-journal-date-format "%A, %d %B %Y"
-                  org-journal-dir "~/Sync/Default/Documents/journal")
-
-            (define-hook-helper org-journal-mode ()
-              (use-variable-fonts)
-              (text-scale-adjust 4)
-              (if smartparens-strict-mode
-                  (smartparens-strict-mode -1))
-              (if show-smartparens-mode
-                  (show-smartparens-mode -1)))
-            (defun org-journal-display-entry-yesterday ()
-              "Show org-journal entry for yesterday"
-              (interactive)
-              (org-journal-read-or-display-entry (yesterday-time)))))
-;; #+END_SRC
-
-
-;; ** Programming
-;; *** flycheck
-
-;; On-the-fly error checking in programming modes?  Yes please.
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package flycheck
-  :diminish " ✓"
-  :defer 5
-  :config (progn
-            (global-flycheck-mode)
-            (setq flycheck-check-syntax-automatically '(save mode-enabled))
-            (setq flycheck-indication-mode 'left-fringe)
-            (with-eval-after-load 'git-gutter-fringe
-              (fringe-helper-define 'flycheck-fringe-bitmap-double-arrow '(center repeated)
-                ".XXX...."))
-            (if (executable-find "eslint_d")
-                (setq flycheck-javascript-eslint-executable "eslint_d"))))
-;; #+END_SRC
-
-;; **** flycheck-pos-tip
-
-;; Show flycheck errors in a little popup, so I don't lose my place
-
-;; #+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
-
-;; **** flycheck-flow
-
-;; #+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
-
-;; *** golang
-
-;; Go has a few packages to inter-operate with other emacs packages.
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package company-go
-  :commands company-go
-  :config (progn
-            (setq company-go-show-annotation t))
-  :init (progn
-          (define-hook-helper go-mode ()
-            (set (make-local-variable 'company-backends)
-                 '(company-go)))))
-
-(use-package go-eldoc
-  :commands go-eldoc-setup
-  :init (progn
-          (add-hook 'go-mode-hook #'go-eldoc-setup)))
-
-(use-package go-projectile
-  :defer t
-  :config (progn
-            (setq go-projectile-switch-gopath 'maybe)))
-
-
-;; #+END_SRC
-
-;; *** ggtags
-
-;; A nice completion backend for programming modes.
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package ggtags
-  :if (executable-find "gtags")
-  :commands turn-on-ggtags-mode
-  :functions (ggtags-navigation-mode-abort)
-  :config (progn
-            (bind-key "q" #'ggtags-navigation-mode-abort ggtags-navigation-mode-map))
-  :init (progn
-          (defun turn-on-ggtags-mode ()
-            (interactive)
-            (ggtags-mode 1))
-          (add-hook 'c-mode-common-hook #'turn-on-ggtags-mode)))
-;; #+END_SRC
-
-;; *** 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.
-
-;; #+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
-
-;; *** imenu-anywhere
-
-;; This is like imenu, but shows functions (or similar top-level
-;; entities) across buffers in the same project.  Neat!
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package imenu-anywhere
-  :bind ("C-x C-." . ivy-imenu-anywhere))
-;; #+END_SRC
-;; *** Lisps
-
-;; **** All
-
-;; 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
-(defcustom lisp-mode-common-hook nil
-  "Hook run when entering any Lisp mode."
-  :type 'hook
-  :group 'lisp)
-
-(create-hook-helper lisp-mode-setup ()
-  :hooks (emacs-lisp-mode-hook
-          scheme-mode-hook
-          lisp-mode-hook
-          clojure-mode-hook)
-  (run-hooks 'lisp-mode-common-hook))
-;; #+END_SRC
-
-;; ***** 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
-(use-package redshank
-  :diminish " Λ"
-  :after (paredit)
-  :config (progn
-            (add-hook 'lisp-mode-common-hook #'turn-on-redshank-mode)))
-;; #+END_SRC
-
-;; **** Emacs Lisp
-
-;; Customise the modeline-display of =emacs-lisp-mode=.  Then make sure
-;; it runs the common lisp hooks.
-
-;; #+BEGIN_SRC emacs-lisp
-(add-hook 'emacs-lisp-mode-hook #'eldoc-mode)
-;; #+END_SRC
-
-;; Go-to function for elisp.  Except it works through the entire Emacs ecosystem.
-
-;; #+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
-
-;; Interactive elisp
-
-;; #+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
-
-;; **** Scheme & Lisp
-
-;; I don’t work with these as often as I would like
-
-;; #+BEGIN_SRC emacs-lisp
-(define-hook-helper lisp-mode ()
-  (set (make-local-variable 'lisp-indent-function)
-       #'common-lisp-indent-function))
-;; #+END_SRC
-
-;; ***** geiser
-
-;; A REPL thing for Scheme.  Hopefully I’ll get to use it more in the
-;; future.
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package geiser
-  :commands (geiser-mode
-             geiser
-             run-geiser
-             run-racket))
-;; #+END_SRC
-
-;; ***** slime
-
-;; A REPL thing (and more) for Lisp.
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package slime
-  :commands (slime)
-  :config (progn
-            (let ((ql-slime-helper (expand-file-name "~/quicklisp/slime-helper.el")))
-              (if (file-exists-p ql-slime-helper)
-                  (load ql-slime-helper))
-              (slime-setup '(slime-fancy slime-asdf)))
-            (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
-
-;; **** Clojure
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package clojure-mode
-  :defer t
-  :init (progn
-          (define-hook-helper cider-repl-mode ()
-            (highlight-changes-mode -1))))
-
-(use-package clj-refactor
-  :defer t
-  :functions (clj-refactor-mode cljr-add-keybindings-with-prefix)
-  :config (progn
-            (cljr-add-keybindings-with-prefix "C-c C-m"))
-  :init (progn
-          (define-hook-helper clojure-mode ()
-            (clj-refactor-mode 1))))
-;; #+END_SRC
-
-;; ***** cider
-
-;; A REPL thing for Clojure
-
-;; #+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
-
-;; *** Auto-compile
-
-;; 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
-
-;; *** 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.
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package cc-mode
-  :defer 5
-  :config (progn
-            (setq c-default-style '((java-mode . "java")
-                                    (awk-mode . "awk")
-                                    (other . "k&r"))
-                  c-basic-offset 4)
-            (c-set-offset 'case-label '+)))
-;; #+END_SRC
-
-;; *** 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
-(use-package quickrun
-  :bind (("C-c C-e" . quickrun)))
-;; #+END_SRC
-
-;; *** Scala
-
-;; Let’s try using Scala.
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package scala-mode)
-;; #+END_SRC
-
-;; And add ensime, an IDE-style environment.
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package ensime)
-;; #+END_SRC
-
-;; *** Web development
-
-;; **** 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.
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package js2-mode
-  :mode (("\\.js\\'" . js2-mode))
-  :interpreter ("node" . js2-mode)
-  :functions (js2-next-error
-              js2--struct-put)
-  :config (progn
-            (define-key js2-mode-map [menu-bar Javascript] nil)
-            (add-hook 'js2-mode-hook #'js2-imenu-extras-mode)
-            (defun ap/js2-prev-error ()
-              (interactive)
-              (js2-next-error -1))
-            (bind-key "M-g M-n" #'js2-next-error js2-mode-map)
-            (bind-key "M-g M-p" #'ap/js2-prev-error js2-mode-map)
-            (setq js2-basic-offset 2
-                  js-switch-indent-offset 2
-                  js2-include-node-externs t
-                  js2-highlight-level 1
-                  js2-strict-missing-semi-warning nil)))
-;; #+END_SRC
-
-;; ***** rjsx-mode
-
-;; A set of advice for js2-jsx-mode to work better with React.
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package rjsx-mode
-  :after js2-mode
-  :if (fboundp #'js2--struct-put)
-  :mode (("\\.jsx\\'" . rjsx-mode)))
-;; #+END_SRC
-
-;; ***** js2-refactor
-
-;; Thanks to the AST provided by js2-mode, refactoring is possible.  This
-;; library implements some refactorings.
-
-;; #+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
-
-;; ***** 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.
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package add-node-modules-path
-  :config (progn
-            (add-hook 'js2-mode-hook #'add-node-modules-path)))
-;; #+END_SRC
-
-;; ***** Flow
-
-;; #+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
-
-;; ***** Indium
-
-;; 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~.
-
-;; For Chrom*, it needs to be launched with
-;; ~--remote-debugging-port=9222~
-
-;; Node will tell you to open an URL in Chrome:
-
-;; ~chrome-devtools://inspector.html?...&ws=127.0.0.1:PORT/PATH~
-
-;; Instead, do this:
-
-;; ~M-x indium-connect-to-nodejs RET 127.0.0.1 RET PORT RET~
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package indium
-  :diminish (indium-interaction-mode . "In")
-  :config (progn
-            (add-hook 'js2-mode-hook #'indium-interaction-mode)))
-;; #+END_SRC
-
-;; **** tern
-
-;; Tern understands javascript.  It adds really clever documented
-;; completions, besides other IDE-like things.
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package tern
-  :diminish tern-mode
-  :if (executable-find "tern")
-  :defer 5
-  :config (progn
-            (setq tern-command (list (executable-find "tern")))
-            (create-hook-helper tern-mode-on ()
-              :hooks (web-mode-hook
-                      js2-mode-hook)
-              (tern-mode +1))))
-
-(with-eval-after-load 'tern
-  (use-package company-tern))
-;; #+END_SRC
-
-;; **** json-mode
-
-;; #+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
-
-;; **** 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.
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package restclient
-  :mode ("\\.api\\'" . restclient-mode)
-  :config (progn
-            (defun imenu-restclient-sections ()
-              (setq imenu-prev-index-position-function nil)
-              (add-to-list 'imenu-generic-expression '("Services" "^## ?\\(.+\\)$" 1) t)
-              (add-to-list 'imenu-generic-expression '("Calls" "^# ?\\(.+\\)$" 1) t))
-            (add-hook 'restclient-mode-hook #'imenu-restclient-sections)))
-
-(use-package company-restclient
-  :after (company restclient)
-  :init (add-to-list 'company-backends #'company-restclient t))
-;; #+END_SRC
-
-;; **** sgml-mode
-
-;; 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
-
-;; **** 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
-(use-package emmet-mode
-  :commands (emmet-mode)
-  :diminish (emmet-mode . " >")
-  :init (progn
-          (setq emmet-indentation 2
-                emmet-self-closing-tag-style " /")
-          (add-hook 'sgml-mode-hook #'emmet-mode)
-          (add-hook 'web-mode-hook #'emmet-mode)
-          (add-hook 'css-mode-hook #'emmet-mode)))
-;; #+END_SRC
-
-;; **** 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.
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package web-mode
-  :mode (("/views/.*\\.php\\'" . web-mode)
-         ("\\.html\\'" . web-mode)
-         ("/templates/.*\\.php\\'" . web-mode)
-         ("\\.ejs\\'" . web-mode)
-         ("\\.njk\\'" . web-mode))
-  :config (progn
-            (setq web-mode-code-indent-offset 2
-                  web-mode-css-indent-offset 2
-                  web-mode-markup-indent-offset 2
-                  web-mode-style-padding 0
-                  web-mode-script-padding 0
-                  web-mode-comment-style 2
-                  web-mode-enable-auto-pairing nil
-                  web-mode-enable-auto-quoting nil)
-            (sp-local-pair '(web-mode) "<%" "%>")))
-;; #+END_SRC
-
-;; *** Live coding
-
-;; Sometimes I might want to show off my emacs usage.
-
-;; #+BEGIN_SRC emacs-lisp
-(defun live-coding ()
-  (interactive)
-  (ap/set-fonts "SF Mono" 18 nil nil t 0.1)
-  (global-command-log-mode 1))
-
-(defun live-coding-stop ()
-  (interactive)
-  (ap/set-fonts-according-to-system)
-  (global-command-log-mode -1))
-;; #+END_SRC
-
-;; **** command-log-mode
-
-;; #+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
-
-;; ** Spelling
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package ispell
-  :bind (("<f8>" . ispell-word))
-  :config (progn
-            (cond
-             ((executable-find "aspell") (setq ispell-program-name "aspell"
-                                               ispell-dictionary "british"
-                                               ispell-really-aspell t
-                                               ispell-really-hunspell nil))
-             ((executable-find "hunspell") (setq ispell-program-name "hunspell"
-                                                 ispell-really-aspell nil
-                                                 ispell-really-hunspell t)))))
-;; #+END_SRC
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package flyspell
-  :diminish "﹏"
-  :config (progn
-            (defun flyspell-detect-ispell-args (&optional run-together)
-              "If RUN-TOGETHER is true, spell check the CamelCase words.
- Please note RUN-TOGETHER will make aspell less capable. So it should only be used in prog-mode-hook."
-              (let (args)
-                (when ispell-program-name
-                  (cond
-                   ((string-match "aspell$" ispell-program-name)
-                    (setq args (list "--sug-mode=ultra"))
-                    (if run-together
-                        (setq args (append args '("--run-together" "--run-together-limit=16" "--run-together-min=2")))))
-                   ((string-match "hunspell$" ispell-program-name)
-                    (setq args nil))))
-                args))
-            ;; `ispell-extra-args' is *always* used when start CLI aspell process
-            (setq-default ispell-extra-args (flyspell-detect-ispell-args t))
-            ;; (setq ispell-cmd-args (flyspell-detect-ispell-args))
-            (defadvice ispell-word (around my-ispell-word activate)
-              (let ((old-ispell-extra-args ispell-extra-args))
-                (ispell-kill-ispell t)
-                ;; use emacs original arguments
-                (setq ispell-extra-args (flyspell-detect-ispell-args))
-                ad-do-it
-                ;; restore our own ispell arguments
-                (setq ispell-extra-args old-ispell-extra-args)
-                (ispell-kill-ispell t)))
-
-            (defadvice flyspell-auto-correct-word (around my-flyspell-auto-correct-word activate)
-              (let* ((old-ispell-extra-args ispell-extra-args))
-                (ispell-kill-ispell t)
-                ;; use emacs original arguments
-                (setq ispell-extra-args (flyspell-detect-ispell-args))
-                ad-do-it
-                ;; restore our own ispell arguments
-                (setq ispell-extra-args old-ispell-extra-args)
-                (ispell-kill-ispell t)))
-            (setq flyspell-issue-message-flag nil)
-
-            (defun fly-text-mode-hook-setup ()
-              ;; Turn off RUN-TOGETHER option when spell check text-mode
-              (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
-
-;; *** Style checking
-
-;; [[https://github.com/ValeLint/vale][Vale]] is a linter, but for prose.  Neat idea!  Salesman is a bad term.
-
-;; #+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
-
-;; ** Scripting
-
-;; Make a shell-script buffer executable after saving it, if it has a shebang.
-
-;; #+BEGIN_SRC emacs-lisp
-(add-hook 'after-save-hook
-          #'executable-make-buffer-file-executable-if-script-p)
-
-(use-package sh-script
-  :mode (("\\.zsh\\'" . shell-script-mode)
-         ("zshenv\\'" . shell-script-mode)
-         ("zshrc\\'"  . shell-script-mode))
-  :config (setq sh-shell-file "/usr/bin/env zsh"
-                sh-indentation 2
-                sh-basic-offset 2))
-;; #+END_SRC
-
-;; #+BEGIN_SRC emacs-lisp
-(add-hook 'shell-mode-hook 'ansi-color-for-comint-mode-on)
-;; #+END_SRC
-
-;; *** eshell
-
-;; 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
-(use-package eshell
-  :bind ("C-c s" .  eshell)
-  :defer 10
-  :functions (eshell/pwd)
-  :config (progn
-            (setq eshell-directory-name "~/.emacs.d/eshell"
-                  eshell-prompt-function (lambda ()
-                                           (concat
-                                            (eshell/pwd)
-                                            "\n$ ")))
-            (define-hook-helper eshell-load ()
-              (bind-key "C-c C-l" #'counsel-esh-history eshell-mode-map))))
-
-(use-package em-smart
-  :ensure nil
-  :commands eshell-smart-initialize
-  :init (progn
-          (add-hook 'eshell-load-hook #'eshell-smart-initialize))
-  :config (progn
-            (setq eshell-where-to-jump 'begin
-                  eshell-review-quick-commands nil
-                  eshell-smart-space-goes-to-end t)))
-
-(autoload #'eshell/cd "em-dirs")
-(defun eshell-goto-current-dir (&optional arg)
-  (interactive "P")
-  (let ((dir default-directory))
-    (eshell arg)
-    (eshell/cd dir)))
-(bind-key "C-c S" #'eshell-goto-current-dir)
-
-
-;; #+END_SRC
-
-;; **** Shells
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package shell
-  :defer t
-  :ensure nil
-  :config (define-key shell-mode-map
-            (kbd "C-d") 'comint-delchar-or-eof-or-kill-buffer))
-
-(use-package comint
-  :defer t
-  :ensure nil
-  :config (bind-key "C-c C-l" #'counsel-shell-history comint-mode-map))
-
-(defun comint-delchar-or-eof-or-kill-buffer (arg)
-  (interactive "p")
-  (if (null (get-buffer-process (current-buffer)))
-      (kill-buffer)
-    (comint-delchar-or-maybe-eof arg)))
-;; #+END_SRC
-
-;; ** Text editing
-
-;; Emacs has an editor within.
-
-;; #+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
-
-;; *** align
-
-;; =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
-(use-package align
-  :defer 10
-  :ensure nil
-  :config (progn
-            (add-to-list 'align-rules-list
-                         '(colon-key-value
-                           (regexp . ":\\(\\s-*\\)")
-                           (modes  . '(js2-mode))))))
-;; #+END_SRC
-
-;; *** Clipboard
-
-;; I like to use the clipboard more than the primary selection in X11.
-
-;; #+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
-
-;; *** Selection
-
-;; I’m quite used to deleting text by selecting it and typing.  Emacs has
-;; a mode for that.
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package delsel
-  :config (delete-selection-mode t))
-;; #+END_SRC
-
-;; Sub-word movement is really nice for camel- and Pascal-case
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package subword
-  :diminish subword-mode
-  :init (global-subword-mode t))
-;; #+END_SRC
-
-;; I find that =zap-up-to-char= normally makes more sense to me than
-;; =zap-to-char=.
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package misc
-  :ensure nil
-  :bind (("M-z" . zap-up-to-char)
-         ("M-Z" . zap-to-char)))
-;; #+END_SRC
-
-;; 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
-(use-package expand-region
-  :bind ("C-M-SPC" . er/expand-region)
-  :config (setq expand-region-fast-keys-enabled nil))
-;; #+END_SRC
-
-;; *** avy
-
-;; Avy is a really nice way to move around files, like ace-jump-mode, but
-;; somehow I prefer it.
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package avy
-  :defer 5
-  :bind (("M-g g" . avy-goto-line)
-         ("M-g M-g" . avy-goto-line)
-         ("C-|" . avy-goto-line)
-         ("M-r" . avy-goto-word-1)
-         ("C-c SPC" . avy-goto-char-timer))
-  :config (progn
-            (avy-setup-default)
-            (setq avy-all-windows nil
-                  avy-keys '(?a ?r ?s ?t ?d ?h ?n ?e ?i ?\;))))
-;; #+END_SRC
-
-;; **** ace-link
-
-;; Visit any link.  Despite the name, this works with avy.
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package ace-link
-  :after avy
-  :config (progn
-            (ace-link-setup-default)
-            (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
-
-;; *** 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.
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package goto-chg
-  :bind ("C-c C-SPC" . goto-last-change))
-;; #+END_SRC
-
-;; *** beginend
-
-;; In special buffers, I would rather have =M->= and =M-<= goto the
-;; logical beginning/end rather than the physical ones.
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package beginend
-  :config (progn
-            (beginend-setup-all)))
-;; #+END_SRC
-
-;; *** 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.
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package multiple-cursors
-  :defer 1
-  :bind* (("C-." . mc/mark-next-like-this)
-          ("C-," . mc/mark-previous-like-this)
-          ("M-<f3>" . mc/mark-all-like-this-dwim)
-          ("C-<f3>" . mc/mark-more-like-this-extended)
-          ("C-S-L" . mc/edit-lines)))
-;; #+END_SRC
-
-;; *** paredit
-
-;; Balanced parentheses in lisps are nice, but all the refactoring and
-;; movement commands are much more interesting.
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package paredit
-  :diminish "()"
-  :config (progn
-            (add-hook 'lisp-mode-common-hook #'enable-paredit-mode)
-            (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
-
-;; *** 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
-
-;; #+BEGIN_SRC emacs-lisp
-(eval-when-compile (require 'smartparens nil :noerror))
-(use-package smartparens-config
-  :ensure smartparens
-  :config (progn
-            (sp-use-smartparens-bindings)
-            (setq sp-highlight-pair-overlay nil)
-            (fset 'wrap-with-paren "\C-](") ;; `sp-select-next-thing-exchange'
-            (bind-key "C-(" #'wrap-with-paren smartparens-mode-map)
-            (bind-key "C-)" #'sp-forward-slurp-sexp smartparens-mode-map)
-            (bind-key "M-<backspace>" #'backward-kill-word smartparens-mode-map)
-            (bind-key "M-?" #'sp-convolute-sexp smartparens-mode-map)
-            (bind-key "C-M-t" #'sp-transpose-sexp smartparens-mode-map)
-            (bind-key "M-R" #'sp-raise-sexp smartparens-mode-map)
-            (bind-key "M-S" #'sp-splice-sexp smartparens-mode-map)
-            (bind-key "C-M-s" #'sp-split-sexp smartparens-mode-map)
-            (bind-key "M-J" #'sp-join-sexp smartparens-mode-map)
-            (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) 
-            (show-smartparens-global-mode t)
-            (smartparens-global-strict-mode t)
-            (define-hook-helper lisp-mode-common ()
-              (smartparens-strict-mode -1)
-              (smartparens-mode -1))))
-;; #+END_SRC
-
-
-;; *** move-text
-
-;; Transposing lines, made easier.
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package move-text
-  :config (move-text-default-bindings))
-;; #+END_SRC
-
-;; *** 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.
-
-;; #+BEGIN_SRC emacs-lisp
-(use-package undo-tree
-  :config (progn
-            (global-undo-tree-mode)
-            ;; Keep region when undoing in region
-            (defadvice undo-tree-undo (around keep-region activate)
-              (if (use-region-p)
-                  (let ((m (set-marker (make-marker) (mark)))
-                        (p (set-marker (make-marker) (point))))
-                    ad-do-it
-                    (goto-char p)
-                    (set-mark m)
-                    (set-marker p nil)
-                    (set-marker m nil))
-                ad-do-it)))
-  :diminish undo-tree-mode)
-;; #+END_SRC
-
-;; *** replace
-
-;; #+BEGIN_SRC emacs-lisp
-(with-eval-after-load "replace.el"
-  (setq case-replace nil))
-;; #+END_SRC
-
-;; *** 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.
-
-;; #+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
-
-;; ** End
-
-;; 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)))
-;; #+END_SRC
+(load-file (expand-file-name "main.el" user-emacs-directory))
+;;; init ends here
diff --git a/emacs/.emacs.d/main.el b/emacs/.emacs.d/main.el
new file mode 100644
index 00000000..0ca1211c
--- /dev/null
+++ b/emacs/.emacs.d/main.el
@@ -0,0 +1,2821 @@
+;;; 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)
+(add-hook 'after-init-hook
+          (lambda ()
+            (setq gc-cons-threshold 800000)))
+(remove-hook 'find-file-hooks #'vc-refresh-state)
+;; #+END_SRC
+
+;; Are we running on Windows via the WSL?
+
+;; #+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
+
+;; *** Compatibility
+
+;; #+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
+
+;; *** 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
+
+;; *** Personal Information
+;; #+BEGIN_SRC emacs-lisp
+(setq user-mail-address "alan@alanpearce.eu"
+      user-full-name "Alan Pearce")
+;; #+end_src
+
+;; ** Packaging
+
+;; *** Use-package
+
+;; #+BEGIN_SRC emacs-lisp
+(eval-and-compile
+  (require 'seq)
+  (defvar nix-emacs (and (string-match "^/nix/store" invocation-directory)
+                         (not (null (seq-some (lambda (dir) (string-match "^/nix/store" dir)) load-path)))))
+
+  (setq tls-checktrust t
+        gnutls-verify-error t
+        package-menu-async t
+        package-user-dir (concat "~/.emacs.d/packages/" emacs-version "/elpa")
+        package-menu-hide-low-priority t)
+  (unless nix-emacs
+    (setq package-archives '(("gnu" . "https://elpa.gnu.org/packages/")
+                             ("melpa-stable" . "https://stable.melpa.org/packages/")
+                             ("melpa" . "https://melpa.org/packages/"))
+          package-pinned-packages '(("use-package" . melpa-stable)
+                                    ("diminish" . melpa-stable)
+                                    ("bind-key" . melpa-stable))
+          package-archive-priorities '(("melpa" . 10)
+                                       ("gnu" . 10)
+                                       ("melpa-stable" . 5)
+                                       ("marmalade" . 0))))
+  (when (eq system-type 'darwin)
+    (with-eval-after-load "gnutls"
+      (add-to-list 'gnutls-trustfiles "/etc/ssl/cert.pem")))
+  (unless nix-emacs
+    (unless (package-installed-p 'use-package)
+      (package-refresh-contents)
+      (package-install 'use-package))))
+(eval-when-compile (require 'use-package))
+(unless (featurep 'use-package)
+  (require 'diminish)
+  (require 'bind-key)
+  (use-package use-package
+    :commands (use-package-autoload-keymap)
+    :defer 5))
+(setq use-package-always-ensure (not nix-emacs)
+      use-package-always-demand (daemonp)
+      package-enable-at-startup nil)
+;; #+END_SRC
+
+;; *** Helpers
+
+;; **** Hook Helpers
+
+;; 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
+(eval-and-compile
+  (use-package hook-helpers))
+;; #+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=
+
+;; #+BEGIN_SRC emacs-lisp
+(setq custom-file "~/.emacs.d/custom.el")
+(load custom-file :noerror :nomessage)
+;; #+END_SRC
+
+;; ** Styles
+
+;; I prefer an always-visible cursor.  Feels less distracting.
+;; #+BEGIN_SRC emacs-lisp
+(when (fboundp #'blink-cursor-mode)
+  (blink-cursor-mode -1))
+;; #+END_SRC
+
+;; Disable all the bars, unless on OSX, in which case, keep the menu bar.
+
+;; #+BEGIN_SRC emacs-lisp
+(when (and menu-bar-mode (not (eq window-system 'ns)))
+  (menu-bar-mode -1))
+(with-eval-after-load 'scroll-bar
+  (set-scroll-bar-mode nil))
+(with-eval-after-load 'tooltip
+  (tooltip-mode -1))
+(with-eval-after-load 'tool-bar
+  (tool-bar-mode -1))
+;; #+END_SRC
+
+;; 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
+
+;; *** Colours
+
+;; 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
+(use-package eziam-light-theme
+  :ensure eziam-theme
+  :disabled t
+  :if (or window-system
+          (daemonp))
+  :defines (eziam-scale-headings)
+  :config (progn
+            (setq eziam-scale-headings nil)
+            (load-theme 'eziam-light t)
+            (custom-theme-set-faces 'user
+                                    '(default ((t (:background "#ffffff"))))
+                                    '(js2-function-call ((t (:underline nil))))
+                                    '(js2-object-property ((t (:slant normal))))
+                                    '(font-lock-keyword-face ((t (:weight normal))))
+                                    '(git-gutter-fr:added ((t (:foreground "#96a4ab"))))
+                                    '(git-gutter-fr:modified ((t (:foreground "#96a4ab"))))
+                                    '(git-gutter-fr:deleted ((t (:foreground "#96a4ab")))))))
+;; #+END_SRC
+
+;; White-theme.  Sounds like a good idea.
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package white-theme
+  :if (or window-system
+          (daemonp))
+  :config (progn
+            (load-theme 'white t)
+            (custom-theme-set-faces 'user
+                                    '(git-gutter-fr:added ((t (:foreground "#b8b8b8"))))
+                                    '(git-gutter-fr:modified ((t (:foreground "#b8b8b8"))))
+                                    '(git-gutter-fr:deleted ((t (:foreground "#b8b8b8"))))
+                                    '(font-lock-string-face ((t (:slant normal)))))))
+;; #+END_SRC
+
+;; Base16 theming allows me have a consistent style between applications
+;; quite easily.
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package base16-theme
+  :if (or window-system
+          (daemonp)))
+;; #+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
+(use-package highlight-stages
+  :diminish highlight-stages-mode)
+;; #+END_SRC
+
+;; *** 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 (or (display-graphic-p)
+          (daemonp))
+
+  (defun use-variable-fonts ()
+    (interactive)
+    (variable-pitch-mode)
+    (setq cursor-type '(bar . 1)))
+
+  (defun ap/set-fonts (mono-face mono-font-size variable-face variable-font-size antialias &optional new-line-spacing)
+    (if (boundp 'ns-antialias-text)
+        (setq ns-antialias-text antialias))
+    (if (boundp 'new-line-spacing)
+      (setq line-spacing new-line-spacing))
+    (when mono-face
+      (let ((default-font (font-spec :family mono-face :size  mono-font-size)))
+        (add-to-list 'default-frame-alist `(font . ,(format "%s %s" mono-face mono-font-size)))
+        (set-face-font 'fixed-pitch default-font)
+        (set-frame-font default-font t t)))
+    (when variable-face
+      (set-face-font 'variable-pitch (font-spec :name variable-face :size variable-font-size))))
+
+  (defun ap/set-fonts-according-to-system ()
+    (interactive)
+    (cond
+     ((eq window-system 'w32)
+      (ap/set-fonts "Liberation Mono" 11 "Segoe UI" 11 t))
+     ((or (eq window-system 'mac)
+          (eq window-system 'ns))
+      (let ((displays (string-to-number (shell-command-to-string "system_profiler SPDisplaysDataType | grep \"Online: Yes\" | wc -l"))))
+        (if (eq displays 1)
+            (ap/set-fonts "Fira Code" 14 "Lucida Grande" 14 t nil)
+          (ap/set-fonts "Monoid" 12 "Helvetica Neue" 12 t 0.1))))
+     ((and (eq window-system 'x)
+           (not (eq system-type 'gnu/linux/windows)))
+      (set-fontset-font "fontset-default" 'unicode (font-spec :name "PT Mono" :size 14))
+      (ap/set-fonts "PT Mono" 14 "Noto Sans" 14 nil))
+     ((and (eq window-system 'x)
+           (eq system-type 'gnu/linux/windows))
+      (ap/set-fonts "Noto Mono" 12 "Sans" 12 nil))))
+
+  (ap/set-fonts-according-to-system))
+;; #+END_SRC
+
+;; 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
+
+;; 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
+(if (eq window-system 'mac)
+    (mac-auto-operator-composition-mode +1)
+    (global-prettify-symbols-mode +1))
+;; #+END_SRC
+
+;; *** 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.
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package page-break-lines
+  :defer 5
+  :diminish page-break-lines-mode
+  :config (progn
+            (global-page-break-lines-mode)
+            (unless (eq (char-displayable-p ?─) (char-displayable-p ?a))
+              (set-fontset-font "fontset-default"
+                                (cons page-break-lines-char page-break-lines-char)
+                                (face-attribute 'default :family)))))
+;; #+END_SRC
+;; *** Modeline
+
+;; #+BEGIN_SRC emacs-lisp
+(column-number-mode -1)
+(line-number-mode -1)
+(size-indication-mode t)
+
+
+(require 'f)
+(setq frame-title-format (list "Emacs"
+                               (if (and nix-emacs invocation-directory)
+                                   (list " (Nix Generation "
+                                         (cadr
+                                          (split-string (f-base
+                                                         (car
+                                                          (last (seq-take-while
+                                                                 (lambda (s) (s-contains? "profile" s))
+                                                                 (split-string
+                                                                  (s-chomp (shell-command-to-string (concat "nix-store -q --roots " invocation-directory)))
+                                                                  "\n")))))
+                                                        "-"))
+                                         " "
+                                         (s-left 6 (nth 3 (f-split invocation-directory)))
+                                         "..."
+                                         (s-right 6 (car (split-string (nth 3 (f-split invocation-directory)) "-")))
+                                         ")"))
+                               '(buffer-file-name " — %f")
+                               '(dired-directory (" — " dired-directory))))
+;; #+END_SRC
+
+;; *** Chrome
+
+;; Sometimes I like to hide clutter.  Other times, it's useful.
+
+;; #+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")
+
+(defun show-mode-line ()
+  (interactive)
+  (setq mode-line-format mode-line-default-format)
+  (when (called-interactively-p 'interactive)
+    (setq-default mode-line-format mode-line-default-format)
+    (setq mode-line-default-hidden nil)))
+(defun hide-mode-line ()
+  (interactive)
+  (setq mode-line-format nil)
+  (when (called-interactively-p 'interactive)
+    (setq-default mode-line-format nil)
+    (setq mode-line-default-hidden t)))
+
+(setq-default cursor-in-non-selected-windows nil)
+
+(defun hide-clutter ()
+  (interactive)
+  (hide-mode-line))
+
+(defun show-clutter ()
+  (interactive)
+  (show-mode-line))
+
+(when mode-line-default-hidden
+  (call-interactively #'hide-mode-line))
+
+(setq-default indicate-buffer-boundaries nil)
+(fringe-mode '(4 . 4))
+
+(defun hide-mode-line-if-default-hidden ()
+  (if mode-line-default-hidden
+      (hide-mode-line)
+    (show-mode-line)))
+
+(add-to-list 'default-frame-alist '(border-width . 0))
+(add-to-list 'default-frame-alist '(internal-border-width . 0))
+(when (or (eq window-system 'x)
+          (eq window-system 'mac))
+  (setq window-divider-default-bottom-width 1
+        window-divider-default-right-width 1
+        window-divider-default-places t)
+  (window-divider-mode +1))
+
+(add-hook 'after-change-major-mode-hook #'hide-mode-line-if-default-hidden)
+
+(add-hook 'minibuffer-setup-hook #'show-mode-line)
+(add-hook 'minibuffer-exit-hook #'hide-mode-line)
+;; #+END_SRC
+
+;; *** Highlight Changes
+
+;; Highlight what just changed when I undo, yank, and so on.
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package volatile-highlights
+  :diminish volatile-highlights-mode
+  :config (progn
+            (volatile-highlights-mode t)))
+;; #+END_SRC
+
+;; *** 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.
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package beacon
+  :diminish beacon-mode
+  :config (progn
+            (beacon-mode +1)
+            (setq beacon-blink-delay 0.25
+                  beacon-blink-duration 0.25
+                  beacon-size 20
+                  beacon-color "#a1b56c")))
+;; #+END_SRC
+
+;; *** Renaming major modes
+
+;; Diminishing major modes does not happen in the same manner as minor
+;; modes.
+
+;; #+BEGIN_SRC emacs-lisp
+(unless (version<= emacs-version "24.4")
+  (use-package cyphejor
+    :defer 2
+    :config (progn
+              (setq cyphejor-rules `(("emacs"       "ε")
+                                     ("diff"        "Δ")
+                                     ("js2"         "js")
+                                     ("magit-status" ,(char-to-string (seq-find #'char-displayable-p '(11942 5848 177))))
+                                     ("inferior"    "i" :prefix)
+                                     ("interaction" "i" :prefix)
+                                     ("interactive" "i" :prefix)
+                                     ("menu"        "▤" :postfix)
+                                     ("ledger"      "Ledger")
+                                     ("mode"        "")
+                                     ("shell"       "sh" :postfix)))
+              (cyphejor-mode 1))))
+;; #+END_SRC
+
+
+;; ** 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.
+
+;; 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
+(use-package exec-path-from-shell
+  :if (or (eq system-type 'darwin)
+          (eq system-type 'gnu/linux/windows)
+          (and (eq system-type 'gnu/linux)
+               (daemonp)))
+  :config (progn
+            (setq exec-path-from-shell-arguments '("-l"))
+            (exec-path-from-shell-initialize)))
+;; #+END_SRC
+
+;; *** 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.
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package nix-sandbox
+  :config (progn
+            (with-eval-after-load 'flycheck
+              (setq flycheck-command-wrapper-function
+                    (lambda (command)
+                      (if (nix-current-sandbox)
+                          (apply 'nix-shell-command (nix-current-sandbox) command)
+                        command))
+                    flycheck-executable-find
+                    (lambda (cmd)
+                      (if (nix-current-sandbox)
+                          (nix-executable-find (nix-current-sandbox) cmd)
+                        (executable-find cmd)))))))
+;; #+END_SRC
+
+;; ** 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.
+
+;; #+BEGIN_SRC emacs-lisp
+(when (eq system-type 'darwin)
+  (set-keyboard-coding-system nil)
+  (custom-set-variables
+   '(mac-option-modifier 'meta)
+   '(mac-right-option-modifier 'none)
+   '(mac-control-modifier 'control)
+   '(mac-right-control-modifier 'left)
+   '(mac-command-modifier 'super)
+   '(mac-right-command-modifier 'left)
+   '(mac-function-modifier 'hyper))
+  (unbind-key "s-x"))
+;; #+END_SRC
+
+;; #+BEGIN_SRC emacs-lisp
+(unbind-key "<f4>")
+(bind-key* "<f5>" #'compile)
+(bind-key* "<f6>" #'kmacro-start-macro-or-insert-counter)
+(bind-key* "<f7>" #'kmacro-end-or-call-macro)
+
+(bind-key* "<apps>" #'execute-extended-command)
+
+(unbind-key "C-z")
+(bind-key* "C-<tab>" #'other-window)
+
+(bind-key* "C-x C-r" #'revert-buffer)
+(bind-key* "C-x C-j" #'delete-indentation)
+(unbind-key "C-x C-c")
+
+(bind-key* "C-c i" #'insert-char)
+(bind-key* "M-/" #'hippie-expand)
+
+(unbind-key "s-h")
+(unbind-key "s-n")
+(unbind-key "s-p")
+(unbind-key "s-w")
+(bind-key* "s-k" #'kill-or-delete-this-buffer-dwim)
+
+(bind-key "C-M-a" #'backward-paragraph text-mode-map)
+(bind-key "C-M-e" #'forward-paragraph text-mode-map)
+
+(bind-key* "s-x" (define-prefix-command 'super-x-map))
+(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
+
+;; *** Crux
+
+;; I can replace most of the simple helper/wrapper functions in my
+;; configuration with crux.el
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package crux
+  :bind (("M-o" . crux-smart-open-line-above)
+         ("C-o" . crux-smart-open-line)
+
+         ("C-x 4 t" . crux-transpose-windows)
+         ("C-c e" . crux-eval-and-replace)
+         ("C-c D" . crux-delete-file-and-buffer)
+         ("C-c R" . crux-rename-file-and-buffer))
+  :config (progn
+            (crux-reopen-as-root-mode +1))
+  :init (progn
+          (defalias 'delete-current-buffer-file #'crux-delete-file-and-buffer)
+          (defalias 'rename-current-buffer-file #'crux-rename-file-and-buffer)))
+;; #+END_SRC
+
+;; ** Projects
+
+;; #+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
+
+;; *** The Silver Searcher
+
+;; #+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
+
+;; *** Ripgrep
+
+;; Step over Silver Search, here comes a new challenger.
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package ripgrep
+  :if (executable-find "rg"))
+
+(use-package projectile-ripgrep
+  :after (ripgrep projectile)
+  :if (executable-find "rg")
+  :bind (("C-c p s r" . projectile-ripgrep)))
+;; #+END_SRC
+
+;; *** Projectile
+
+;; Projectile is awesome for working in projects, especially VCS-backed
+;; ones.
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package projectile
+  :bind (("s-p" . projectile-switch-project)
+         ("C-c C-f" . projectile-find-file)
+         ("s-x s-f" . projectile-find-file)
+         ("C-x g" . projectile-vc)
+         ("s-G"   . projectile-vc))
+  :demand t
+  :diminish projectile-mode
+  :config (progn
+            (projectile-mode +1)
+            (add-to-list 'projectile-globally-ignored-directories ".stversions")
+
+            (defun yarn-install (&optional arg)
+              (interactive "P")
+              (projectile-with-default-dir (projectile-project-root)
+                (cmd-to-echo "yarn" "install")))
+
+            (defun yarn-add-dev (package)
+              (interactive "spackage: ")
+              (projectile-with-default-dir (projectile-project-root)
+                (cmd-to-echo "yarn" (concat "add --dev " package))))
+
+            (defun yarn-add (package)
+              (interactive "spackage: ")
+              (projectile-with-default-dir (projectile-project-root)
+                (cmd-to-echo "yarn" (concat "add " package))))
+
+            (defun yarn-run (cmd)
+              (interactive (list
+                            (projectile-completing-read "command: " (alist-get 'scripts (json-read-file (expand-file-name "package.json" (projectile-project-root)))))))
+              (projectile-with-default-dir (projectile-project-root)
+                (cmd-to-echo "yarn" (concat "run " cmd))))
+
+            (defun ap/open-project (&optional arg)
+              (interactive "P")
+              (let ((project-dir (projectile-completing-read
+                                  "Open project: "
+                                  (ghq--find-projects))))
+                (projectile-switch-project-by-name
+                 (expand-file-name project-dir (ghq--find-root)) arg)))
+
+            (setq projectile-switch-project-action #'projectile-commander
+                  projectile-completion-system 'ivy
+                  projectile-create-missing-test-files t)
+
+            (defun ap/projectile-test-suffix (project-type)
+              (cond
+               ((member project-type '(node-yarn node-npm)) ".test")
+               (t (projectile-test-suffix project-type))))
+            (setq projectile-test-suffix-function #'ap/projectile-test-suffix)
+
+            (projectile-register-project-type 'node-yarn '("yarn.lock") "yarn start" "yarn test")
+            (projectile-register-project-type 'node '("package.json") "npm start" "npm test")))
+
+(use-package counsel-projectile
+  :after (counsel projectile)
+  :config (progn
+            (counsel-projectile-on)
+            (def-projectile-commander-method ?A
+              "Find rg on project."
+              (call-interactively #'counsel-projectile-rg))
+            (define-key projectile-mode-map [remap counsel-projectile-ag] #'counsel-projectile-rg)))
+;; #+END_SRC
+
+;; *** 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.
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package vc
+  :defer t
+  :bind (("C-x v C" . vc-resolve-conflicts))
+  :config (progn
+            (setq vc-follow-symlinks t)
+            (setq vc-ignore-dir-regexp (format "\\(%s\\)\\|\\(%s\\)"
+                                               vc-ignore-dir-regexp
+                                               tramp-file-name-regexp))))
+;; #+END_SRC
+
+;; *** 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.
+
+;; #+BEGIN_SRC emacs-lisp
+(eval-when-compile (require 'fringe-helper))
+(use-package git-gutter-fringe
+  :defer 2
+  :diminish git-gutter-mode
+  :config (progn
+            (global-git-gutter-mode 1)
+            ;; places the git gutter outside the margins.
+            (setq-default fringes-outside-margins t)
+            ;; thin fringe bitmaps
+            (fringe-helper-define 'git-gutter-fr:added '(center repeated)
+              ".XXX....")
+            (fringe-helper-define 'git-gutter-fr:modified '(center repeated)
+              ".XXX....")
+            (fringe-helper-define 'git-gutter-fr:deleted 'bottom
+              ".......X"
+              "......XX"
+              ".....XXX"
+              "....XXXX")
+            (setq git-gutter-fr:side 'right-fringe)))
+;; #+END_SRC
+
+;; *** 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=
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package magit
+  :defer 5
+  :commands (magit-status)
+  :config (progn (setq magit-completing-read-function #'ivy-completing-read
+                       magit-popup-use-prefix-argument 'default
+                       magit-display-buffer-function #'magit-display-buffer-fullcolumn-most-v1
+                       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
+
+;; *** git-messenger
+
+;; Popup the last commit that changed the line at point.
+
+;; #+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
+
+;; *** 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.
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package git-timemachine
+  :commands git-timemachine)
+;; #+END_SRC
+
+;; *** 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.
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package ghq
+  :if (executable-find "ghq"))
+;; #+END_SRC
+
+;; ** Files
+
+;; *** Auto-saving
+
+;; Auto-save everything to a temporary directory, instead of cluttering
+;; the filesystem.  I don’t want emacs-specific lockfiles, either.
+
+;; #+BEGIN_SRC emacs-lisp
+(setq auto-save-file-name-transforms `((".*" ,temporary-file-directory t))
+      create-lockfiles nil)
+;; #+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
+(let ((backup-dir (expand-file-name "~/.emacs.d/backups/")))
+  (unless (file-directory-p backup-dir)
+    (make-directory backup-dir))
+  (setq backup-directory-alist `((".*" . ,backup-dir))
+        backup-by-copying-when-linked t
+        backup-by-copying-when-mismatch t))
+(if (eq system-type 'darwin)
+    (setq delete-by-moving-to-trash t)
+  (if (and (executable-find "trash") (not (fboundp #'system-move-file-to-trash)))
+      (defun system-move-file-to-trash (file)
+        (call-process (executable-find "trash")
+                      nil 0 nil
+                      file))))
+;; #+END_SRC
+
+;; *** autorevert
+
+;; #+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
+
+;; *** Encoding
+
+;; 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
+(prefer-coding-system 'utf-8)
+(setq-default buffer-file-coding-system 'utf-8-auto-unix)
+;; #+END_SRC
+
+;; *** Buffer-file management
+
+;; 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
+(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
+
+;; I often want to rename or delete the file that I’m currently visiting
+;; with a buffer.
+
+;; #+BEGIN_SRC emacs-lisp
+(defun kill-or-delete-this-buffer-dwim (&optional arg)
+  "Kills current buffer.  With prefix arg, delete it."
+  (interactive "P")
+  (if (equal arg '(4))
+      (delete-current-buffer-file)
+    (if server-buffer-clients
+        (server-edit)
+      (let ((buf (buffer-name)))
+        (when (equal buf "*HTTP Response*")
+          (other-window 1))
+        (kill-buffer buf)))))
+;; #+END_SRC
+
+;; *** Whitespace
+
+;; Show bad whitespace, so that I can fix it.
+
+;; #+BEGIN_SRC emacs-lisp
+(defun show-trailing-whitespace-on ()
+  (interactive)
+  (setq-local show-trailing-whitespace t))
+(defun show-trailing-whitespace-off ()
+  (interactive)
+  (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
+
+;; *** shrink-whitespace
+
+;; DWIM whitespace removal.  So I don’t need =M-SPC=, =M-\= and =C-x o=
+;; for similar things any more.
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package shrink-whitespace
+  :bind ("M-SPC" . shrink-whitespace))
+;; #+END_SRC
+
+;; *** Tramp
+
+;; 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
+(use-package tramp
+  :defer 7
+  :config (progn
+            (unless (getenv "SSH_AUTH_SOCK")
+              (setenv "SSH_AUTH_SOCK" (format "/run/user/%s/ssh-agent" (user-uid))))
+            (setq tramp-default-method "ssh"
+                  tramp-default-user-alist '(("\\`su\\(do\\)?\\'" nil "root"))
+                  tramp-backup-directory-alist backup-directory-alist
+                  tramp-completion-reread-directory-timeout 60
+                  tramp-ssh-controlmaster-options nil
+                  backup-enable-predicate (lambda (name)
+                                            (and (normal-backup-enable-predicate name)
+                                                 (not (let ((method (file-remote-p name 'method)))
+                                                        (when (stringp method)
+                                                          (member method '("su" "sudo")))))))
+                  tramp-shell-prompt-pattern "\\(?:^\\|
\\)[^]#$%>\n]*#?[]#$%>❯›] *\\(\\[\\??[0-9;]*[a-zA-Z] *\\)*")
+            (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
+
+;; *** ediff
+
+;; I like a horizonal diff setup, with everything in one frame.
+
+;; #+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
+
+;; ** 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.
+
+;; #+BEGIN_SRC emacs-lisp
+(setq-default tab-width 2
+              indent-tabs-mode nil)
+(electric-indent-mode +1)
+;; #+END_SRC
+
+
+;; *** smart-tabs-mode
+
+;; Not related to [[smart-tab][=smart-tab=]], this mode indents with tabs and aligns
+;; with spaces.  Perfect!
+
+;; #+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
+
+;; *** editorconfig
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package editorconfig
+  :diminish "EC"
+  :config (editorconfig-mode 1))
+;; #+END_SRC
+
+;; *** dtrt-indent-mode
+
+;; Sometimes people use different indentation settings.  [[https://github.com/jscheid/dtrt-indent][dtrt-indent]]
+;; guesses the correct settings for me.
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package dtrt-indent
+  :config (progn
+            (define-hook-helper after-change-major-mode ()
+              (unless (and (boundp editorconfig-mode)
+                           editorconfig-mode)
+                (dtrt-indent-adapt)))
+            (defadvice dtrt-indent-try-set-offset (after toggle-smart-tabs activate)
+              (smart-tabs-mode (or indent-tabs-mode -1)))))
+;; #+END_SRC
+
+;; ** Security
+
+;; *** password-store
+
+;; 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
+
+;; *** Ibuffer
+;; Ibuffer is quite nice for listing all buffers.
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package ibuffer
+  :bind (("C-x C-b" . ibuffer))
+  :config (progn
+            (setq ibuffer-saved-filter-groups
+                  (quote (("default"
+                           ("org" (mode . org-mode))
+                           ("emacs" (mode . emacs-lisp-mode))
+                           ("zsh" (filename . "/zsh"))
+                           ("server" (filename . "/su:root@server"))))))
+
+            ;; Human-readable base-2 size column
+            (define-ibuffer-column size-h
+              (:name "Size" :inline t)
+              (cond
+               ((> (buffer-size) 1024)
+                (format "%7.2fK" (/ (buffer-size) 1024.0)))
+               ((> (buffer-size) 1048576)
+                (format "%7.2fM" (/ (buffer-size) 1048576.0)))
+               (t
+                (format "%8d" (buffer-size)))))
+
+            (setq ibuffer-formats
+                  '((mark modified read-only " "
+                          (name 18 18 :left :elide)
+                          " "
+                          (size-h 9 -1 :right)
+                          " "
+                          (mode 16 16 :left :elide)
+                          " "
+                          filename-and-process)))))
+;; #+END_SRC
+
+;; *** Relative Buffer names
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package relative-buffers
+  :defer 15
+  :config (progn
+            (global-relative-buffers-mode)))
+;; #+END_SRC
+;; *** Narrowing
+
+;; Enable it without prompting
+
+;; #+BEGIN_SRC emacs-lisp
+(put 'narrow-to-defun  'disabled nil)
+(put 'narrow-to-page   'disabled nil)
+(put 'narrow-to-region 'disabled nil)
+;; #+END_SRC
+
+;; *** 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
+(use-package ace-window
+  :bind (("s-s" . ace-window))
+  :config (progn
+            (setq aw-dispatch-always t
+                  aw-dispatch-alist '((?k aw-delete-window " Ace - Delete Window")
+                                      (?K aw-delete-window)
+                                      (?m aw-swap-window " Ace - Swap Window")
+                                      (?f aw-flip-window)
+                                      (?v aw-split-window-vert " Ace - Split Vert Window")
+                                      (?b aw-split-window-horz " Ace - Split Horz Window")
+                                      (?m delete-other-windows " Ace - Maximize Window")
+                                      (?l delete-other-windows)
+                                      (?, winner-undo)
+                                      (?. winner-redo))
+                  aw-keys '(?a ?r ?s ?t ?n ?e ?i ?o))))
+;; #+END_SRC
+
+;; ** Windows
+
+;; Scrolling is tricky.  I use this setup to help me keep track of the
+;; point whilst I’m moving about.
+
+;; #+BEGIN_SRC emacs-lisp
+(setq scroll-conservatively 100
+      scroll-margin 1
+      scroll-preserve-screen-position t
+      mouse-wheel-scroll-amount '(1 ((shift) . 1) ((control)))
+      split-height-threshold 80
+      split-width-threshold 160
+      frame-resize-pixelwise nil)
+(if (boundp 'ns-pop-up-frames)
+    (setq ns-pop-up-frames nil))
+;; #+END_SRC
+
+;; *** 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.
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package eyebrowse
+  :config (progn
+            (setq eyebrowse-new-workspace t)
+            (when (eq system-type 'darwin)
+              (bind-keys
+               ("s-0" . eyebrowse-switch-to-window-config-0)
+               ("s-1" . eyebrowse-switch-to-window-config-1)
+               ("s-2" . eyebrowse-switch-to-window-config-2)
+               ("s-3" . eyebrowse-switch-to-window-config-3)
+               ("s-4" . eyebrowse-switch-to-window-config-4)
+               ("s-5" . eyebrowse-switch-to-window-config-5)
+               ("s-6" . eyebrowse-switch-to-window-config-6)
+               ("s-7" . eyebrowse-switch-to-window-config-7)
+               ("s-8" . eyebrowse-switch-to-window-config-8)
+               ("s-9" . eyebrowse-switch-to-window-config-9)))
+            (bind-keys*
+             ("M-0" . eyebrowse-switch-to-window-config-0)
+             ("M-1" . eyebrowse-switch-to-window-config-1)
+             ("M-2" . eyebrowse-switch-to-window-config-2)
+             ("M-3" . eyebrowse-switch-to-window-config-3)
+             ("M-4" . eyebrowse-switch-to-window-config-4)
+             ("M-5" . eyebrowse-switch-to-window-config-5)
+             ("M-6" . eyebrowse-switch-to-window-config-6)
+             ("M-7" . eyebrowse-switch-to-window-config-7)
+             ("M-8" . eyebrowse-switch-to-window-config-8)
+             ("M-9" . eyebrowse-switch-to-window-config-9))
+            (eyebrowse-mode +1)))
+;; #+END_SRC
+
+;; ** Sessions
+
+;; *** Desktop
+;; Save my Emacs session and restore it on startup.
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package desktop
+  :ensure nil
+  :config (progn
+            (setq desktop-dirname (expand-file-name "desktop/" user-emacs-directory)
+                  desktop-base-file-name "emacs.desktop"
+                  desktop-base-lock-name "lock"
+                  desktop-path (list desktop-dirname)
+                  desktop-save 'if-exists
+                  desktop-files-not-to-save "^$"
+                  desktop-load-locked-desktop nil)
+            (unless (file-directory-p desktop-dirname)
+              (make-directory desktop-dirname))
+            (desktop-save-mode 1)))
+;; #+END_SRC
+
+;; *** winner
+
+;; Undo, for window-based commands.
+
+;; #+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
+
+;; *** windmove
+
+;; Directional window movement
+
+;; #+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
+
+;; I have a [[https://alanpearce.uk][blog]] that I publish with hugo.
+
+;; #+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
+
+;; ** Completion
+
+;; Make built-in completion a bit more intelligent, by adding substring
+;; and initial-based completion and ignoring case.
+
+;; #+BEGIN_SRC emacs-lisp
+(setq completion-styles '(basic initials partial-completion substring)
+      completion-ignore-case t
+      tab-always-indent 'complete)
+;; #+END_SRC
+
+;; *** 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.
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package company
+  :commands (company-mode)
+  :diminish "Cmpl"
+  :bind (("C-<tab>" . company-complete)
+         ("TAB" . company-indent-or-complete-common))
+  :init (progn
+          (add-hook 'prog-mode-hook #'company-mode-on)
+          (setq company-backends '(company-bbdb company-web-html company-tern company-nxml company-css company-eclim company-semantic company-elisp
+                                                company-clang company-xcode company-cmake company-capf
+                                                company-files (company-gtags
+                                                               company-etags company-keywords) company-oddmuse)
+                company-frontends '(company-pseudo-tooltip-unless-just-one-frontend
+                                    company-preview-frontend
+                                    company-echo-metadata-frontend)
+                company-idle-delay .3
+                company-begin-commands '(self-insert-command)
+                company-auto-complete #'company-explicit-action-p
+                company-auto-complete-chars '(?\ ?\( ?\) ?.)
+                company-tooltip-align-annotations t
+                company-selection-wrap-around t)))
+;; #+END_SRC
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package company-web
+  :after company)
+;; #+END_SRC
+
+;;; ** Dates & Times
+
+;; *** Calendar
+
+;; 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
+
+;; 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."
+  (interactive "P")
+  (let ((format (cond
+                 ((not prefix) "%Y-%m-%d")
+                 ((equal prefix '(4)) "%d/%m/%Y")
+                 ((equal prefix '(16)) "%A, %d %B %Y"))))
+    (insert (format-time-string format))))
+
+(defun insert-datetime (prefix)
+  "Insert the current date and time."
+  (interactive "P")
+  (let ((format (cond
+                 ((not prefix) "%Y-%m-%d %H:%M:%S")
+                 ((equal prefix '(4)) "%Y-%m-%dT%H:%M:%SZ"))))
+    (insert (format-time-string format))))
+;; #+END_SRC
+
+;; #+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
+
+;; ** 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.
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package dired
+  :defer 3
+  :ensure nil
+  :config (progn
+            (bind-key "<return>" #'dired-find-file dired-mode-map)
+            (bind-key "^" (lambda () (interactive) (find-alternate-file "..")) dired-mode-map)
+            (setq dired-dwim-target t
+                  dired-recursive-copies 'top
+                  dired-recursive-deletes (if delete-by-moving-to-trash
+                                              'always
+                                              'top)
+                  dired-listing-switches "-alh")
+            (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
+
+;; Don’t show uninteresting files in dired listings.
+
+;; #+BEGIN_SRC emacs-lisp
+(defun turn-on-dired-omit-mode ()
+  (interactive)
+  (dired-omit-mode 1))
+
+(use-package dired-x
+  :commands (dired-omit-mode
+             dired-expunge)
+  :ensure nil
+  :config (progn
+            (setq dired-omit-files "#\\|\\.$"
+                  dired-omit-verbose nil
+                  dired-find-subdir t
+                  dired-bind-jump nil))
+  :init (progn
+          (add-hook 'dired-mode-hook #'turn-on-dired-omit-mode)))
+;; #+END_SRC
+
+;; Expand subfolders like a tree inside the parent
+
+;; #+BEGIN_SRC emacs-lisp
+(with-eval-after-load 'dired
+  (use-package dired-subtree
+    :functions (dired-subtree--get-ov
+                dired-subtree-maybe-up)
+    :init (progn
+            (setq dired-subtree-use-backgrounds nil)
+            (defun dired-subtree-maybe-up ()
+              "Jump up one subtree or directory"
+              (interactive)
+              (let ((ov (dired-subtree--get-ov)))
+                (if ov
+                    (progn (goto-char (overlay-start ov))
+                           (dired-previous-line 1))
+                  (dired-up-directory))))
+            (bind-key "^" #'dired-subtree-maybe-up dired-mode-map)
+            (bind-key "i" #'dired-subtree-toggle dired-mode-map))))
+;; #+END_SRC
+
+;; *** Disk usage
+
+;; Combine dired and du (disk usage).
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package dired-du
+  :after dired
+  :config (progn
+            (setq dired-du-size-format t)))
+;; #+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.
+
+;; #+BEGIN_SRC emacs-lisp
+(with-eval-after-load 'dired
+  (use-package dired-narrow
+    :bind (:map dired-mode-map
+                ("/" . dired-narrow))))
+;; #+END_SRC
+
+;; ** Documentation
+
+;; *** 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.
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package ehelp
+  :bind-keymap ("C-h" . ehelp-map))
+;; #+END_SRC
+
+;; *** discover-my-major
+
+;; A nicer way to browse keybindings for major modes.
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package discover-my-major
+  :bind ("<f1>" . discover-my-major))
+;; #+END_SRC
+
+;; *** which-key
+
+;; Popup keybindings following a prefix automatically.
+
+;; #+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
+
+;; *** eldoc
+
+;; Documentation in the echo-area (where the minibuffer is displayed) is
+;; rather useful.
+
+;; #+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
+
+;; *** 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.
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package gnus
+  :config (progn
+            (setq gnus-gcc-mark-as-read t
+                  mml-secure-openpgp-encrypt-to-self t
+                  send-mail-function #'smtpmail-send-it
+                  message-send-mail-function #'smtpmail-send-it)))
+
+(with-eval-after-load "gnus-mime"
+  (define-key gnus-mime-button-map " " #'gnus-mime-view-part-externally))
+
+(with-eval-after-load "mailcap"
+  (when (eq system-type 'darwin)
+    (mailcap-add-mailcap-entry "application" "pdf" '((viewer . "/usr/bin/qlmanage -p %s") (type . "application/pdf")))))
+
+(with-eval-after-load "mm-decode"
+  (add-to-list 'mm-discouraged-alternatives "text/html")
+  (add-to-list 'mm-discouraged-alternatives "text/richtext"))
+;; #+END_SRC
+
+;; *** BBDB
+
+;; As I'm using Emacs for email, it makes sense to have contact
+;; information here as well.
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package bbdb
+  :config (progn
+            (bbdb-initialize 'gnus 'message 'pgp)
+            (bbdb-mua-auto-update-init 'gnus 'message)
+            (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
+
+;; ** Misc
+
+;; #+BEGIN_SRC emacs-lisp
+(defvar *init-file*
+  (file-truename user-init-file)
+  "Where the emacs init file really is, passing through symlinks.")
+(set-register ?e `(file . ,*init-file*))
+
+(defun ap/remove-extra-cr ()
+  "Remove extraneous CR codes from a file"
+  (interactive)
+  (save-excursion
+    (goto-char (point-min))
+    (while (search-forward "
+  " nil t)
+      (replace-match ""))))
+
+(use-package rect
+  :ensure nil
+  :init (defun copy-rectangle (start end)
+          "Copy the region-rectangle."
+          (interactive "r")
+          (setq killed-rectangle (extract-rectangle start end))))
+
+(defun shell-execute (to-current-buffer)
+  (interactive "P")
+  (let ((file-buffer (if (buffer-file-name)
+                         (file-name-nondirectory (buffer-file-name))
+                       ""))
+        (command (read-shell-command "Shell command: " nil nil nil)))
+    (shell-command (replace-regexp-in-string "%" file-buffer command) to-current-buffer)))
+
+(defun process-exit-code (program &rest args)
+  "Run PROGRAM with ARGS and return the exit code"
+  (apply 'call-process program nil nil nil args))
+
+(defun narrow-to-region-indirect (start end)
+  "Restrict editing in this buffer to the current region, indirectly."
+  (interactive "r")
+  (deactivate-mark)
+  (let ((buf (clone-indirect-buffer nil nil)))
+    (with-current-buffer buf
+      (narrow-to-region start end))
+    (switch-to-buffer buf)))
+
+(bind-key* "M-!" #'shell-execute)
+(bind-key* "C-x r M-w" #'copy-rectangle)
+;; #+END_SRC
+
+;; *** Auxillary Configuration
+
+;; #+BEGIN_SRC emacs-lisp
+(require 'pinentry)
+
+(defvar have-private-key
+  (file-exists-p (expand-file-name "secring.gpg" "~/.gnupg/")))
+
+(defvar gpg-agent-ssh-sock
+  (or (getenv "GPG_AGENT_INFO")
+      (concat "/run/user/" (number-to-string (user-uid)) "/gnupg/S.gpg-agent.ssh")))
+
+(defun read-gpg-file (file)
+  (let ((file-to-decrypt (expand-file-name file user-emacs-directory))
+	(ctx (epg-make-context epa-protocol)))
+    (if (file-exists-p file-to-decrypt)
+	(epg-decrypt-file ctx file-to-decrypt nil)
+      (message "Decrypting %s...failed" file-to-decrypt)
+      (error "File %s does not exist" file-to-decrypt))))
+
+(defun load-gpg (file)
+  (if have-private-key
+      (load file)
+    (message "WARNING: Couldn't load %s (No gpg key found)" file)))
+
+; load this in a post-frame hook because gpg-agent asks for a password on first
+; startup and caches it. Don't want emacs daemon to hang because of gpg-agent.
+(defun load-private-data ()
+  (interactive)
+  (if (not (file-exists-p (expand-file-name (concat (system-name) ".el.gpg") user-emacs-directory)))
+      (message "No encrypted configuration matches system name `%s'" (system-name))
+    (if (not have-private-key)
+        (message "ERROR: Private GPG key not found")
+      (unless (or (getenv "GPG_AGENT_INFO")
+                  (getenv "SSH_AUTH_SOCK"))
+        (start-process "gpg-agent" nil "gpg-agent" "--daemon")
+        (setenv "SSH_AUTH_SOCK" gpg-agent-ssh-sock))
+      (setq password-cache-expiry nil)
+      (unless (file-exists-p (concat pinentry--socket-dir "pinentry"))
+        (pinentry-start)
+        (add-hook 'kill-emacs-hook 'pinentry-stop))
+      (add-to-list 'load-suffixes ".el.gpg")
+      (load-gpg (expand-file-name (system-name) user-emacs-directory)))))
+
+(defun first-frame-hook (frame)
+  (remove-hook 'after-make-frame-functions #'first-frame-hook)
+  (run-at-time nil nil 'load-private-data))
+
+(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
+
+;; ** 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.
+
+;; #+BEGIN_SRC emacs-lisp
+(setq enable-recursive-minibuffers t)
+(minibuffer-depth-indicate-mode t)
+;; #+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
+(setq minibuffer-prompt-properties '(read-only t point-entered minibuffer-avoid-prompt face minibuffer-prompt))
+;; #+END_SRC
+
+;; 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
+
+;; *** swiper/ivy
+
+;; Ivy is the new kid on the completion block.  It seems to be a strong
+;; replacement for helm so far.
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package swiper
+  :bind (("C-s" . swiper)
+         ("C-r" . swiper)
+         ("C-=" . swiper))
+  :diminish ivy-mode
+  :demand t
+  :config (progn
+            (ivy-mode 1)
+            (setq ivy-re-builders-alist '((t . ivy--regex-plus))
+                  ivy-extra-directories '("./"))
+            (ivy-set-actions 'ivy-switch-buffer '(("k" (lambda (x)
+                                                         (kill-buffer x)
+                                                         (ivy--reset-state ivy-last))
+                                                   "kill")))
+            (add-to-list 'ivy-initial-inputs-alist '(counsel-M-x . ""))))
+;; #+END_SRC
+
+;; *** counsel
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package counsel
+  :config (progn
+            (bind-key "M-x" #'counsel-M-x)
+            (bind-key "<apps>" #'counsel-M-x)
+            (bind-key "<menu>" #'counsel-M-x)
+            (bind-key "C-c M-x" #'execute-extended-command)
+            (bind-key "C-x C-f" #'counsel-find-file)
+            (bind-key "M-y" #'counsel-yank-pop)
+            (bind-key "C-x i" #'counsel-imenu)
+            (bind-key "M-y" #'ivy-next-line ivy-minibuffer-map)
+            (defadvice counsel-find-file (after find-file-sudo activate)
+              "Find file as root if necessary."
+              (when (and buffer-file-name
+                         (not (file-writable-p buffer-file-name)))
+                (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
+
+
+;; *** 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.
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package smex
+  :commands (smex
+             smex-update
+             smex-initialize)
+  :config (progn
+            (setq smex-key-advice-ignore-menu-bar t
+                  smex-auto-update nil)
+            (defun smex-update-after-load (_unused)
+              (if (boundp 'smex-cache)
+                  (smex-update)))
+            (add-hook 'after-load-functions 'smex-update-after-load))
+  :init (progn
+          (setq smex-history-length 100
+                smex-save-file (concat user-emacs-directory
+                                       "smex-items"))))
+;; #+END_SRC
+
+;; *** 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.
+
+;; #+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
+
+;; 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
+
+;; =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
+
+;; 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)))
+
+(use-package dockerfile-mode
+  :mode (("Dockerfile\\'" . dockerfile-mode)))
+
+(use-package nix-mode
+  :mode (("\\.nix\\'" . nix-mode)))
+
+(define-derived-mode xmonad-mode haskell-mode "XM")
+(add-to-list 'auto-mode-alist '("xmobarrc\\'" . xmonad-mode))
+(add-to-list 'auto-mode-alist '("xmonad.hs\\'" . xmonad-mode))
+
+(use-package nginx-mode
+  :defer t
+  :mode (("/nginx/servers/" . nginx-mode)
+         ("/nginx/.*\\.d/" . nginx-mode)))
+
+(use-package lua-mode
+  :defer t)
+
+(use-package ruby-mode
+  :mode (("\\.rb\\'" . ruby-mode)
+         ("\\.cap\\'" . ruby-mode)))
+
+(use-package go-mode
+  :mode (("\\.go\\'" . go-mode)))
+
+(use-package jinja2-mode
+  :mode (("\\.j2\\'" . jinja2-mode)
+         ("\\.jinja\\'" . jinja2-mode)))
+
+(use-package scss-mode
+  :defer t
+  :config (progn
+            (setq scss-compile-at-save nil)))
+
+(use-package toml-mode
+  :mode ("\\.toml\\'" . toml-mode))
+
+(use-package yaml-mode
+  :mode (("/group_vars/.*" . yaml-mode)
+         ("/host_vars/.*" . yaml-mode)))
+
+(define-derived-mode ansible-mode yaml-mode "Ansible")
+(add-to-list 'auto-mode-alist '("\\(?:ansible.+\\|roles/.+/\\(?:tasks\\|handlers\\)\\)/.+\\.yml\\'" . ansible-mode))
+
+(define-derived-mode saltstack-mode yaml-mode "Salt")
+(add-to-list 'auto-mode-alist '("\\.sls\\'" . saltstack-mode))
+;; #+END_SRC
+
+;; *** ledger
+
+;; I use [[http://ledger-cli.org/][=ledger=]] to manage my finances.  It has an Emacs mode, which
+;; works really nicely.
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package ledger-mode
+  :mode ("\\.ledger\\'" . ledger-mode)
+  :functions ledger-report
+  :init (progn
+          (defun open-budget ()
+            (interactive)
+            (projectile-switch-project-by-name "~/Sync/Default")
+            (find-file (expand-file-name "ledger/my.ledger" (projectile-project-root)))
+            (ledger-report "Budget (Cumulative)" nil)))
+  :config (progn
+            (setq ledger-use-iso-dates t
+                  ledger-post-use-completion-engine :ido
+                  ledger-reconcile-default-commodity "€"
+                  ledger-clear-whole-transactions t
+                  ledger-narrow-on-reconcile t
+                  ledger-reports `(("Monthly Expenses" "ledger -f %(ledger-file) reg -M \\^Flex --real -X EUR -l \"payee != 'Opening Balances'\"")
+                                   ("Average Monthly Expenses (Past 12 Months)" ,(concat "ledger -f %(ledger-file) -b "
+                                                                                    (format-time-string "%Y-%m" (time-add (current-time) (days-to-time -365)))
+                                                                                    " --monthly --average balance ^Flex"))
+                                   ("Expenses:This Month" "ledger -f %(ledger-file) bal \\^Flex -p \"this month\"")
+                                   ("On-budget Balances" "ledger -f %(ledger-file) bal --current -R :Budget: Assets:Receivable Liabilities:Personal")
+                                   ("All Account Balances" "ledger -f %(ledger-file) bal --current -R \\^Assets \\^Liabilities")
+                                   ("Budget Values (Current Month)" "ledger -f %(ledger-file) bal -p \"this month\" --limit \"payee=~/budget/\" \\^Funds")
+                                   ("Budget (Cumulative)" "ledger -f %(ledger-file) bal -E \\^Funds \\^Assets:Budget$")
+                                   ("Budget Allocation" "ledger -f %(ledger-file) bal -p \"this month\" --limit \"payee=~/budget/\" \\^Funds --format \"\\
+                    %-17((depth_spacer)+(partial_account))\\
+                    %10(percent(market(display_total), market(parent.total)))\\
+                    %16(market(display_total))\n%/\"")
+                                   ("bal" "ledger -f %(ledger-file) bal")
+                                   ("reg" "ledger -f %(ledger-file) reg")
+                                   ("equity" "ledger -f %(ledger-file) equity")
+                                   ("payee" "ledger -f %(ledger-file) reg @%(payee)")
+                                   ("account" "ledger -f %(ledger-file) reg %(account)")))))
+;; #+END_SRC
+
+;; *** Markdown
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package markdown-mode
+  :defer t
+  :config (progn
+            (add-hook 'markdown-mode-hook #'turn-on-auto-fill)))
+;; #+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-ified source code.  I think this might work better than
+;; lentic-mode, whilst also being more general.
+
+;; #+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
+(use-package org
+  :bind (("C-c C-a" . org-agenda-list)
+         ("C-c a" . org-agenda)
+         ("C-c l" . org-store-link))
+  :defer 8
+  :init (setq org-replace-disputed-keys t
+              org-ellipsis "…")
+  :config (progn
+            (setq org-directory "~/Sync/org"
+                  org-agenda-files `(,(concat org-directory "/agenda"))
+
+                  org-default-notes-file (concat org-directory "/notes")
+
+                  ;; ‘Remember’: new items at top
+                  org-reverse-note-order t
+
+                  org-modules '(org-protocol)
+
+                  ;; Add time done to ‘done’ tasks
+                  org-log-done 'time
+
+                  org-list-allow-alphabetical t
+
+                  org-adapt-indentation nil
+
+                  org-pretty-entities t
+
+                  org-table-duration-custom-format 'seconds
+
+                  org-src-fontify-natively nil
+
+                  org-export-have-math t
+
+                  org-blank-before-new-entry '((heading . t)
+                                               (plain-list-item . auto))
+                  org-fontify-done-headline t
+
+                  org-goto-interface 'outline-path-completion
+
+                  org-outline-path-complete-in-steps nil
+
+                  org-todo-keywords '((sequence "BACKLOG(b)" "TODO(t)" "WAIT(w@/!)" "STARTED(s!)" "|" "DONE(d!)")
+                                      (sequence "|" "CANCELLED(c@)"))
+                  org-log-into-drawer "LOGBOOK")
+            (set-register ?o `(file . ,(expand-file-name "organiser.org" org-directory)))
+            (add-hook 'org-mode-hook #'turn-on-auto-fill)
+            (org-load-modules-maybe t)))
+
+(use-package org-src
+  :ensure nil
+  :after org
+  :config (progn
+            (bind-key "C-x C-s" #'org-edit-src-exit org-src-mode-map)))
+;; #+END_SRC
+
+;; ***** 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.
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package ob-core
+  :defer t
+  :ensure nil
+  :config (progn
+            (org-babel-do-load-languages 'org-babel-load-languages
+                                         '((ledger . t)
+                                           (sh . t)))
+            (setq org-src-tab-acts-natively t
+                  org-edit-src-content-indentation 0
+                  org-src-preserve-indentation t)))
+;; #+END_SRC
+
+;; ***** org-journal
+
+;; I can use this to keep a journal.  I should use it.
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package org-journal
+  :bind ("s-j" . org-journal-new-entry)
+  :defer 20
+  :config (progn
+            (setq org-journal-date-format "%A, %d %B %Y"
+                  org-journal-dir "~/Sync/Default/Documents/journal")
+
+            (define-hook-helper org-journal-mode ()
+              (use-variable-fonts)
+              (text-scale-adjust 4)
+              (if smartparens-strict-mode
+                  (smartparens-strict-mode -1))
+              (if show-smartparens-mode
+                  (show-smartparens-mode -1)))
+            (defun org-journal-display-entry-yesterday ()
+              "Show org-journal entry for yesterday"
+              (interactive)
+              (org-journal-read-or-display-entry (yesterday-time)))))
+;; #+END_SRC
+
+
+;; ** Programming
+;; *** flycheck
+
+;; On-the-fly error checking in programming modes?  Yes please.
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package flycheck
+  :diminish " ✓"
+  :defer 5
+  :config (progn
+            (global-flycheck-mode)
+            (setq flycheck-check-syntax-automatically '(save mode-enabled))
+            (setq flycheck-indication-mode 'left-fringe)
+            (with-eval-after-load 'git-gutter-fringe
+              (fringe-helper-define 'flycheck-fringe-bitmap-double-arrow '(center repeated)
+                ".XXX...."))
+            (if (executable-find "eslint_d")
+                (setq flycheck-javascript-eslint-executable "eslint_d"))))
+;; #+END_SRC
+
+;; **** flycheck-pos-tip
+
+;; Show flycheck errors in a little popup, so I don't lose my place
+
+;; #+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
+
+;; **** flycheck-flow
+
+;; #+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
+
+;; *** golang
+
+;; Go has a few packages to inter-operate with other emacs packages.
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package company-go
+  :commands company-go
+  :config (progn
+            (setq company-go-show-annotation t))
+  :init (progn
+          (define-hook-helper go-mode ()
+            (set (make-local-variable 'company-backends)
+                 '(company-go)))))
+
+(use-package go-eldoc
+  :commands go-eldoc-setup
+  :init (progn
+          (add-hook 'go-mode-hook #'go-eldoc-setup)))
+
+(use-package go-projectile
+  :defer t
+  :config (progn
+            (setq go-projectile-switch-gopath 'maybe)))
+
+
+;; #+END_SRC
+
+;; *** ggtags
+
+;; A nice completion backend for programming modes.
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package ggtags
+  :if (executable-find "gtags")
+  :commands turn-on-ggtags-mode
+  :functions (ggtags-navigation-mode-abort)
+  :config (progn
+            (bind-key "q" #'ggtags-navigation-mode-abort ggtags-navigation-mode-map))
+  :init (progn
+          (defun turn-on-ggtags-mode ()
+            (interactive)
+            (ggtags-mode 1))
+          (add-hook 'c-mode-common-hook #'turn-on-ggtags-mode)))
+;; #+END_SRC
+
+;; *** 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.
+
+;; #+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
+
+;; *** imenu-anywhere
+
+;; This is like imenu, but shows functions (or similar top-level
+;; entities) across buffers in the same project.  Neat!
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package imenu-anywhere
+  :bind ("C-x C-." . ivy-imenu-anywhere))
+;; #+END_SRC
+;; *** Lisps
+
+;; **** All
+
+;; 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
+(defcustom lisp-mode-common-hook nil
+  "Hook run when entering any Lisp mode."
+  :type 'hook
+  :group 'lisp)
+
+(create-hook-helper lisp-mode-setup ()
+  :hooks (emacs-lisp-mode-hook
+          scheme-mode-hook
+          lisp-mode-hook
+          clojure-mode-hook)
+  (run-hooks 'lisp-mode-common-hook))
+;; #+END_SRC
+
+;; ***** 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
+(use-package redshank
+  :diminish " Λ"
+  :after (paredit)
+  :config (progn
+            (add-hook 'lisp-mode-common-hook #'turn-on-redshank-mode)))
+;; #+END_SRC
+
+;; **** Emacs Lisp
+
+;; Customise the modeline-display of =emacs-lisp-mode=.  Then make sure
+;; it runs the common lisp hooks.
+
+;; #+BEGIN_SRC emacs-lisp
+(add-hook 'emacs-lisp-mode-hook #'eldoc-mode)
+;; #+END_SRC
+
+;; Go-to function for elisp.  Except it works through the entire Emacs ecosystem.
+
+;; #+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
+
+;; Interactive elisp
+
+;; #+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
+
+;; **** Scheme & Lisp
+
+;; I don’t work with these as often as I would like
+
+;; #+BEGIN_SRC emacs-lisp
+(define-hook-helper lisp-mode ()
+  (set (make-local-variable 'lisp-indent-function)
+       #'common-lisp-indent-function))
+;; #+END_SRC
+
+;; ***** geiser
+
+;; A REPL thing for Scheme.  Hopefully I’ll get to use it more in the
+;; future.
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package geiser
+  :commands (geiser-mode
+             geiser
+             run-geiser
+             run-racket))
+;; #+END_SRC
+
+;; ***** slime
+
+;; A REPL thing (and more) for Lisp.
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package slime
+  :commands (slime)
+  :config (progn
+            (let ((ql-slime-helper (expand-file-name "~/quicklisp/slime-helper.el")))
+              (if (file-exists-p ql-slime-helper)
+                  (load ql-slime-helper))
+              (slime-setup '(slime-fancy slime-asdf)))
+            (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
+
+;; **** Clojure
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package clojure-mode
+  :defer t
+  :init (progn
+          (define-hook-helper cider-repl-mode ()
+            (highlight-changes-mode -1))))
+
+(use-package clj-refactor
+  :defer t
+  :functions (clj-refactor-mode cljr-add-keybindings-with-prefix)
+  :config (progn
+            (cljr-add-keybindings-with-prefix "C-c C-m"))
+  :init (progn
+          (define-hook-helper clojure-mode ()
+            (clj-refactor-mode 1))))
+;; #+END_SRC
+
+;; ***** cider
+
+;; A REPL thing for Clojure
+
+;; #+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
+
+;; *** Auto-compile
+
+;; 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
+
+;; *** 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.
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package cc-mode
+  :defer 5
+  :config (progn
+            (setq c-default-style '((java-mode . "java")
+                                    (awk-mode . "awk")
+                                    (other . "k&r"))
+                  c-basic-offset 4)
+            (c-set-offset 'case-label '+)))
+;; #+END_SRC
+
+;; *** 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
+(use-package quickrun
+  :bind (("C-c C-e" . quickrun)))
+;; #+END_SRC
+
+;; *** Scala
+
+;; Let’s try using Scala.
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package scala-mode)
+;; #+END_SRC
+
+;; And add ensime, an IDE-style environment.
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package ensime)
+;; #+END_SRC
+
+;; *** Web development
+
+;; **** 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.
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package js2-mode
+  :mode (("\\.js\\'" . js2-mode))
+  :interpreter ("node" . js2-mode)
+  :functions (js2-next-error
+              js2--struct-put)
+  :config (progn
+            (define-key js2-mode-map [menu-bar Javascript] nil)
+            (add-hook 'js2-mode-hook #'js2-imenu-extras-mode)
+            (defun ap/js2-prev-error ()
+              (interactive)
+              (js2-next-error -1))
+            (bind-key "M-g M-n" #'js2-next-error js2-mode-map)
+            (bind-key "M-g M-p" #'ap/js2-prev-error js2-mode-map)
+            (setq js2-basic-offset 2
+                  js-switch-indent-offset 2
+                  js2-include-node-externs t
+                  js2-highlight-level 1
+                  js2-strict-missing-semi-warning nil)))
+;; #+END_SRC
+
+;; ***** rjsx-mode
+
+;; A set of advice for js2-jsx-mode to work better with React.
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package rjsx-mode
+  :after js2-mode
+  :if (fboundp #'js2--struct-put)
+  :mode (("\\.jsx\\'" . rjsx-mode)))
+;; #+END_SRC
+
+;; ***** js2-refactor
+
+;; Thanks to the AST provided by js2-mode, refactoring is possible.  This
+;; library implements some refactorings.
+
+;; #+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
+
+;; ***** 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.
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package add-node-modules-path
+  :config (progn
+            (add-hook 'js2-mode-hook #'add-node-modules-path)))
+;; #+END_SRC
+
+;; ***** Flow
+
+;; #+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
+
+;; ***** Indium
+
+;; 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~.
+
+;; For Chrom*, it needs to be launched with
+;; ~--remote-debugging-port=9222~
+
+;; Node will tell you to open an URL in Chrome:
+
+;; ~chrome-devtools://inspector.html?...&ws=127.0.0.1:PORT/PATH~
+
+;; Instead, do this:
+
+;; ~M-x indium-connect-to-nodejs RET 127.0.0.1 RET PORT RET~
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package indium
+  :diminish (indium-interaction-mode . "In")
+  :config (progn
+            (add-hook 'js2-mode-hook #'indium-interaction-mode)))
+;; #+END_SRC
+
+;; **** tern
+
+;; Tern understands javascript.  It adds really clever documented
+;; completions, besides other IDE-like things.
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package tern
+  :diminish tern-mode
+  :if (executable-find "tern")
+  :defer 5
+  :config (progn
+            (setq tern-command (list (executable-find "tern")))
+            (create-hook-helper tern-mode-on ()
+              :hooks (web-mode-hook
+                      js2-mode-hook)
+              (tern-mode +1))))
+
+(with-eval-after-load 'tern
+  (use-package company-tern))
+;; #+END_SRC
+
+;; **** json-mode
+
+;; #+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
+
+;; **** 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.
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package restclient
+  :mode ("\\.api\\'" . restclient-mode)
+  :config (progn
+            (defun imenu-restclient-sections ()
+              (setq imenu-prev-index-position-function nil)
+              (add-to-list 'imenu-generic-expression '("Services" "^## ?\\(.+\\)$" 1) t)
+              (add-to-list 'imenu-generic-expression '("Calls" "^# ?\\(.+\\)$" 1) t))
+            (add-hook 'restclient-mode-hook #'imenu-restclient-sections)))
+
+(use-package company-restclient
+  :after (company restclient)
+  :init (add-to-list 'company-backends #'company-restclient t))
+;; #+END_SRC
+
+;; **** sgml-mode
+
+;; 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
+
+;; **** 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
+(use-package emmet-mode
+  :commands (emmet-mode)
+  :diminish (emmet-mode . " >")
+  :init (progn
+          (setq emmet-indentation 2
+                emmet-self-closing-tag-style " /")
+          (add-hook 'sgml-mode-hook #'emmet-mode)
+          (add-hook 'web-mode-hook #'emmet-mode)
+          (add-hook 'css-mode-hook #'emmet-mode)))
+;; #+END_SRC
+
+;; **** 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.
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package web-mode
+  :mode (("/views/.*\\.php\\'" . web-mode)
+         ("\\.html\\'" . web-mode)
+         ("/templates/.*\\.php\\'" . web-mode)
+         ("\\.ejs\\'" . web-mode)
+         ("\\.njk\\'" . web-mode))
+  :config (progn
+            (setq web-mode-code-indent-offset 2
+                  web-mode-css-indent-offset 2
+                  web-mode-markup-indent-offset 2
+                  web-mode-style-padding 0
+                  web-mode-script-padding 0
+                  web-mode-comment-style 2
+                  web-mode-enable-auto-pairing nil
+                  web-mode-enable-auto-quoting nil)
+            (sp-local-pair '(web-mode) "<%" "%>")))
+;; #+END_SRC
+
+;; *** Live coding
+
+;; Sometimes I might want to show off my emacs usage.
+
+;; #+BEGIN_SRC emacs-lisp
+(defun live-coding ()
+  (interactive)
+  (ap/set-fonts "SF Mono" 18 nil nil t 0.1)
+  (global-command-log-mode 1))
+
+(defun live-coding-stop ()
+  (interactive)
+  (ap/set-fonts-according-to-system)
+  (global-command-log-mode -1))
+;; #+END_SRC
+
+;; **** command-log-mode
+
+;; #+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
+
+;; ** Spelling
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package ispell
+  :bind (("<f8>" . ispell-word))
+  :config (progn
+            (cond
+             ((executable-find "aspell") (setq ispell-program-name "aspell"
+                                               ispell-dictionary "british"
+                                               ispell-really-aspell t
+                                               ispell-really-hunspell nil))
+             ((executable-find "hunspell") (setq ispell-program-name "hunspell"
+                                                 ispell-really-aspell nil
+                                                 ispell-really-hunspell t)))))
+;; #+END_SRC
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package flyspell
+  :diminish "﹏"
+  :config (progn
+            (defun flyspell-detect-ispell-args (&optional run-together)
+              "If RUN-TOGETHER is true, spell check the CamelCase words.
+ Please note RUN-TOGETHER will make aspell less capable. So it should only be used in prog-mode-hook."
+              (let (args)
+                (when ispell-program-name
+                  (cond
+                   ((string-match "aspell$" ispell-program-name)
+                    (setq args (list "--sug-mode=ultra"))
+                    (if run-together
+                        (setq args (append args '("--run-together" "--run-together-limit=16" "--run-together-min=2")))))
+                   ((string-match "hunspell$" ispell-program-name)
+                    (setq args nil))))
+                args))
+            ;; `ispell-extra-args' is *always* used when start CLI aspell process
+            (setq-default ispell-extra-args (flyspell-detect-ispell-args t))
+            ;; (setq ispell-cmd-args (flyspell-detect-ispell-args))
+            (defadvice ispell-word (around my-ispell-word activate)
+              (let ((old-ispell-extra-args ispell-extra-args))
+                (ispell-kill-ispell t)
+                ;; use emacs original arguments
+                (setq ispell-extra-args (flyspell-detect-ispell-args))
+                ad-do-it
+                ;; restore our own ispell arguments
+                (setq ispell-extra-args old-ispell-extra-args)
+                (ispell-kill-ispell t)))
+
+            (defadvice flyspell-auto-correct-word (around my-flyspell-auto-correct-word activate)
+              (let* ((old-ispell-extra-args ispell-extra-args))
+                (ispell-kill-ispell t)
+                ;; use emacs original arguments
+                (setq ispell-extra-args (flyspell-detect-ispell-args))
+                ad-do-it
+                ;; restore our own ispell arguments
+                (setq ispell-extra-args old-ispell-extra-args)
+                (ispell-kill-ispell t)))
+            (setq flyspell-issue-message-flag nil)
+
+            (defun fly-text-mode-hook-setup ()
+              ;; Turn off RUN-TOGETHER option when spell check text-mode
+              (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
+
+;; *** Style checking
+
+;; [[https://github.com/ValeLint/vale][Vale]] is a linter, but for prose.  Neat idea!  Salesman is a bad term.
+
+;; #+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
+
+;; ** Scripting
+
+;; Make a shell-script buffer executable after saving it, if it has a shebang.
+
+;; #+BEGIN_SRC emacs-lisp
+(add-hook 'after-save-hook
+          #'executable-make-buffer-file-executable-if-script-p)
+
+(use-package sh-script
+  :mode (("\\.zsh\\'" . shell-script-mode)
+         ("zshenv\\'" . shell-script-mode)
+         ("zshrc\\'"  . shell-script-mode))
+  :config (setq sh-shell-file "/usr/bin/env zsh"
+                sh-indentation 2
+                sh-basic-offset 2))
+;; #+END_SRC
+
+;; #+BEGIN_SRC emacs-lisp
+(add-hook 'shell-mode-hook 'ansi-color-for-comint-mode-on)
+;; #+END_SRC
+
+;; *** eshell
+
+;; 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
+(use-package eshell
+  :bind ("C-c s" .  eshell)
+  :defer 10
+  :functions (eshell/pwd)
+  :config (progn
+            (setq eshell-directory-name "~/.emacs.d/eshell"
+                  eshell-prompt-function (lambda ()
+                                           (concat
+                                            (eshell/pwd)
+                                            "\n$ ")))
+            (define-hook-helper eshell-load ()
+              (bind-key "C-c C-l" #'counsel-esh-history eshell-mode-map))))
+
+(use-package em-smart
+  :ensure nil
+  :commands eshell-smart-initialize
+  :init (progn
+          (add-hook 'eshell-load-hook #'eshell-smart-initialize))
+  :config (progn
+            (setq eshell-where-to-jump 'begin
+                  eshell-review-quick-commands nil
+                  eshell-smart-space-goes-to-end t)))
+
+(autoload #'eshell/cd "em-dirs")
+(defun eshell-goto-current-dir (&optional arg)
+  (interactive "P")
+  (let ((dir default-directory))
+    (eshell arg)
+    (eshell/cd dir)))
+(bind-key "C-c S" #'eshell-goto-current-dir)
+
+
+;; #+END_SRC
+
+;; **** Shells
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package shell
+  :defer t
+  :ensure nil
+  :config (define-key shell-mode-map
+            (kbd "C-d") 'comint-delchar-or-eof-or-kill-buffer))
+
+(use-package comint
+  :defer t
+  :ensure nil
+  :config (bind-key "C-c C-l" #'counsel-shell-history comint-mode-map))
+
+(defun comint-delchar-or-eof-or-kill-buffer (arg)
+  (interactive "p")
+  (if (null (get-buffer-process (current-buffer)))
+      (kill-buffer)
+    (comint-delchar-or-maybe-eof arg)))
+;; #+END_SRC
+
+;; ** Text editing
+
+;; Emacs has an editor within.
+
+;; #+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
+
+;; *** align
+
+;; =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
+(use-package align
+  :defer 10
+  :ensure nil
+  :config (progn
+            (add-to-list 'align-rules-list
+                         '(colon-key-value
+                           (regexp . ":\\(\\s-*\\)")
+                           (modes  . '(js2-mode))))))
+;; #+END_SRC
+
+;; *** Clipboard
+
+;; I like to use the clipboard more than the primary selection in X11.
+
+;; #+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
+
+;; *** Selection
+
+;; I’m quite used to deleting text by selecting it and typing.  Emacs has
+;; a mode for that.
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package delsel
+  :config (delete-selection-mode t))
+;; #+END_SRC
+
+;; Sub-word movement is really nice for camel- and Pascal-case
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package subword
+  :diminish subword-mode
+  :init (global-subword-mode t))
+;; #+END_SRC
+
+;; I find that =zap-up-to-char= normally makes more sense to me than
+;; =zap-to-char=.
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package misc
+  :ensure nil
+  :bind (("M-z" . zap-up-to-char)
+         ("M-Z" . zap-to-char)))
+;; #+END_SRC
+
+;; 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
+(use-package expand-region
+  :bind ("C-M-SPC" . er/expand-region)
+  :config (setq expand-region-fast-keys-enabled nil))
+;; #+END_SRC
+
+;; *** avy
+
+;; Avy is a really nice way to move around files, like ace-jump-mode, but
+;; somehow I prefer it.
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package avy
+  :defer 5
+  :bind (("M-g g" . avy-goto-line)
+         ("M-g M-g" . avy-goto-line)
+         ("C-|" . avy-goto-line)
+         ("M-r" . avy-goto-word-1)
+         ("C-c SPC" . avy-goto-char-timer))
+  :config (progn
+            (avy-setup-default)
+            (setq avy-all-windows nil
+                  avy-keys '(?a ?r ?s ?t ?d ?h ?n ?e ?i ?\;))))
+;; #+END_SRC
+
+;; **** ace-link
+
+;; Visit any link.  Despite the name, this works with avy.
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package ace-link
+  :after avy
+  :config (progn
+            (ace-link-setup-default)
+            (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
+
+;; *** 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.
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package goto-chg
+  :bind ("C-c C-SPC" . goto-last-change))
+;; #+END_SRC
+
+;; *** beginend
+
+;; In special buffers, I would rather have =M->= and =M-<= goto the
+;; logical beginning/end rather than the physical ones.
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package beginend
+  :config (progn
+            (beginend-setup-all)))
+;; #+END_SRC
+
+;; *** 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.
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package multiple-cursors
+  :defer 1
+  :bind* (("C-." . mc/mark-next-like-this)
+          ("C-," . mc/mark-previous-like-this)
+          ("M-<f3>" . mc/mark-all-like-this-dwim)
+          ("C-<f3>" . mc/mark-more-like-this-extended)
+          ("C-S-L" . mc/edit-lines)))
+;; #+END_SRC
+
+;; *** paredit
+
+;; Balanced parentheses in lisps are nice, but all the refactoring and
+;; movement commands are much more interesting.
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package paredit
+  :diminish "()"
+  :config (progn
+            (add-hook 'lisp-mode-common-hook #'enable-paredit-mode)
+            (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
+
+;; *** 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
+
+;; #+BEGIN_SRC emacs-lisp
+(eval-when-compile (require 'smartparens nil :noerror))
+(use-package smartparens-config
+  :ensure smartparens
+  :config (progn
+            (sp-use-smartparens-bindings)
+            (setq sp-highlight-pair-overlay nil)
+            (fset 'wrap-with-paren "\C-](") ;; `sp-select-next-thing-exchange'
+            (bind-key "C-(" #'wrap-with-paren smartparens-mode-map)
+            (bind-key "C-)" #'sp-forward-slurp-sexp smartparens-mode-map)
+            (bind-key "M-<backspace>" #'backward-kill-word smartparens-mode-map)
+            (bind-key "M-?" #'sp-convolute-sexp smartparens-mode-map)
+            (bind-key "C-M-t" #'sp-transpose-sexp smartparens-mode-map)
+            (bind-key "M-R" #'sp-raise-sexp smartparens-mode-map)
+            (bind-key "M-S" #'sp-splice-sexp smartparens-mode-map)
+            (bind-key "C-M-s" #'sp-split-sexp smartparens-mode-map)
+            (bind-key "M-J" #'sp-join-sexp smartparens-mode-map)
+            (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) 
+            (show-smartparens-global-mode t)
+            (smartparens-global-strict-mode t)
+            (define-hook-helper lisp-mode-common ()
+              (smartparens-strict-mode -1)
+              (smartparens-mode -1))))
+;; #+END_SRC
+
+
+;; *** move-text
+
+;; Transposing lines, made easier.
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package move-text
+  :config (move-text-default-bindings))
+;; #+END_SRC
+
+;; *** 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.
+
+;; #+BEGIN_SRC emacs-lisp
+(use-package undo-tree
+  :config (progn
+            (global-undo-tree-mode)
+            ;; Keep region when undoing in region
+            (defadvice undo-tree-undo (around keep-region activate)
+              (if (use-region-p)
+                  (let ((m (set-marker (make-marker) (mark)))
+                        (p (set-marker (make-marker) (point))))
+                    ad-do-it
+                    (goto-char p)
+                    (set-mark m)
+                    (set-marker p nil)
+                    (set-marker m nil))
+                ad-do-it)))
+  :diminish undo-tree-mode)
+;; #+END_SRC
+
+;; *** replace
+
+;; #+BEGIN_SRC emacs-lisp
+(with-eval-after-load "replace.el"
+  (setq case-replace nil))
+;; #+END_SRC
+
+;; *** 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.
+
+;; #+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
+
+;; ** End
+
+;; 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)))
+;; #+END_SRC