Loads of changes to use use-package way more
[emacs.git] / .emacs.d / config / emacs.org
index d9cd3b8..4d9392f 100644 (file)
@@ -12,7 +12,7 @@
 :END:
 The following functions are used throughout my config, and so I load
 them first.
-
+*** safe-load
 safe-load does not break emacs initialization, should a file be
 unreadable while emacs boots up.
 #+BEGIN_SRC emacs-lisp :tangle yes
@@ -37,7 +37,7 @@ unreadable while emacs boots up.
   (if (string-equal safe-load-error-list "") ()
                (message (concat "****** error loading: " safe-load-error-list))))
 #+END_SRC
-
+*** Local autoloads
 I have some stuff put away in my local dir. I don't want to load it all
 at startup time, so it is using the autoload feature. For that to work
 load the loaddefs, so autoload knows where to grab stuff
@@ -45,7 +45,7 @@ load the loaddefs, so autoload knows where to grab stuff
 (safe-load (concat jj-elisp-dir "/tiny/loaddefs.el"))
 (safe-load (concat jj-elisp-local-dir "/loaddefs.el"))
 #+END_SRC
-
+*** Keep *scratch* around
 Always ensure to have a scratch buffer around.
 #+BEGIN_SRC emacs-lisp :tangle yes
 (with-current-buffer (get-buffer-create "*scratch*")
@@ -53,7 +53,7 @@ Always ensure to have a scratch buffer around.
     (make-local-variable 'kill-buffer-query-functions)
     (add-hook 'kill-buffer-query-functions 'kill-scratch-buffer))
 #+END_SRC
-
+*** add-auto-mode
 Handier way to add modes to auto-mode-alist
 #+BEGIN_SRC emacs-lisp :tangle yes
 (defun add-auto-mode (mode &rest patterns)
@@ -61,12 +61,35 @@ Handier way to add modes to auto-mode-alist
   (dolist (pattern patterns)
     (add-to-list 'auto-mode-alist (cons pattern mode))))
 #+END_SRC
-
+*** config helpers use-package/bind-key
 Helpers for the config
+https://github.com/jwiegley/use-package
 #+BEGIN_SRC emacs-lisp :tangle yes
 (require 'use-package)
 (require 'bind-key)
 #+END_SRC
+*** hook-into-modes
+[2014-05-20 Tue 22:36]
+#+BEGIN_SRC emacs-lisp :tangle yes
+(defmacro hook-into-modes (func modes)
+  `(dolist (mode-hook ,modes)
+     (add-hook mode-hook ,func)))
+#+END_SRC
+
+*** elpa
+The Emacs Lisp Package Archive contains things I want.
+#+BEGIN_SRC emacs-lisp :tangle yes
+  (when (> emacs-major-version 23)
+    (require 'package)
+    (setq package-user-dir (expand-file-name "elpa" jj-elisp-dir))
+    (package-initialize)
+    (add-to-list 'package-archives '("marmalade"    . "http://marmalade-repo.org/packages/"))
+    (add-to-list 'package-archives '("melpa-stable" . "http://melpa-stable.milkbox.net/packages/"))
+    (add-to-list 'package-archives '("melpa"        . "http://melpa.milkbox.net/packages/"))
+    (add-to-list 'package-archives '("elpy"         . "http://jorgenschaefer.github.io/packages/"))
+    (add-to-list 'package-archives '("gnu"          . "http://elpa.gnu.org/packages/"))
+    )
+#+END_SRC
 
 ** Path settings
 *** Load path
@@ -78,10 +101,10 @@ I also disliked the repeated /add-to-list/ lines, so I now just have
 one variable and go over that in a loop.
 #+BEGIN_SRC emacs-lisp :tangle yes
 (defvar jj-elisp-subdirs '(local gnus icicle org/contrib tiny mo-git-blame cedet
-                           cedet/eieio ecb jdee/lisp sunrise multiple-cursors
-                           auto-complete yasnippet magit mmm emms/lisp
-                           elpy find-file-in-project fuzzy idomenu nose
-                           popup pyvenv git-rebase-mode git-commit-mode)
+-                           cedet/eieio ecb jdee/lisp sunrise multiple-cursors
+-                           auto-complete yasnippet magit mmm emms/lisp
+-                           elpy find-file-in-project fuzzy idomenu nose
+-                           popup pyvenv git-rebase-mode git-commit-mode)
   "List of subdirectories in jj-elisp-dir to add to load-path")
 
 (let (dirval)
@@ -98,7 +121,7 @@ one variable and go over that in a loop.
 
 *** Info path
 Help emacs to find the info files
-#+BEGIN_SRC emacs-lisp :tangle yes
+#+BEGIN_SRC emacs-lisp :tangle no
 (setq Info-directory-list '("~/emacs/info"
                             "/usr/local/share/info/"
                             "/usr/local/info/"
@@ -128,9 +151,7 @@ I dislike the startup message
 
 Usually I want the lines to break at 72 characters.
 #+BEGIN_SRC emacs-lisp :tangle yes
-(if (version<= emacs-version "22")
-    (setq default-fill-column 72)
-  (setq fill-column 72))
+(setq fill-column 72)
 #+END_SRC
 
 And it is nice to have a final newline in files.
@@ -171,19 +192,17 @@ Emacs forbids a certain set of commands, as they can be very confusing
 for new users. Enable them.
 #+BEGIN_SRC emacs-lisp :tangle yes
 (put 'narrow-to-region 'disabled nil)
-(put 'narrow-to-page 'disabled nil)
-(put 'narrow-to-defun 'disabled nil)
-(put 'upcase-region 'disabled nil)
-(put 'downcase-region 'disabled nil)
+(put 'narrow-to-page   'disabled nil)
+(put 'narrow-to-defun  'disabled nil)
+(put 'upcase-region    'disabled nil)
+(put 'downcase-region  'disabled nil)
 #+END_SRC
 
 *** Look / Theme
 I've tried various different fonts and while I like the Terminus font
 most for my shells, in Emacs Inconsolata clearly wins.
 #+BEGIN_SRC emacs-lisp :tangle yes
-(if (version<= emacs-version "22")
-    (set-default-font "Inconsolata-14")
-  (set-frame-font "Inconsolata-14"))
+(set-frame-font "Inconsolata-14")
 #+END_SRC
 
 I always use dark backgrounds, so tell Emacs about it. No need to
@@ -197,7 +216,7 @@ switched through multiple themes doing it in emacs too, but never
 entirely liked it. Until I found solarized, which is now not only my
 emacs theme, but also for most of my other software too, especially my
 shell. Consistent look is great.
-#+BEGIN_SRC emacs-lisp :tangle yes
+#+BEGIN_SRC emacs-lisp :tangle no
 (if (or (> emacs-major-version 23) (boundp 'custom-theme-load-path))
     (progn
       (defun jj-init-theme ()
@@ -215,6 +234,22 @@ shell. Consistent look is great.
   (color-theme-solarized-dark)
 )
 #+END_SRC
+#+BEGIN_SRC emacs-lisp :tangle yes
+(use-package solarized
+  :load-path "elisp/emacs-color-theme-solarized"
+  :init
+  (progn
+    (defun jj-init-theme ()
+      (interactive)
+      (if (eq jj-color-style 'dark )(load-theme 'solarized-dark t)
+        (load-theme 'solarized-light t))
+      (set-face-attribute 'org-date nil :underline nil)
+      (message "Initializing theme solarized-dark")
+      )
+    (add-to-list 'custom-theme-load-path jj-theme-dir)
+    (add-hook 'after-init-hook 'jj-init-theme)
+    (jj-init-theme)))
+#+END_SRC
 
 Make the fringe (gutter) smaller, the argument is a width in pixels (the default is 8)
 #+BEGIN_SRC emacs-lisp :tangle yes
@@ -289,10 +324,16 @@ modeline in red as soon as you are over the defined limit.
 (setq display-time-24hr-format t)
 (setq modelinepos-column-limit 72)
 
-(require 'modeline-posn)
-(set-face-foreground 'modelinepos-column-warning "grey20")
-(set-face-background 'modelinepos-column-warning "red")
+(use-package modeline-posn
+  :ensure modeline-posn
+  :config
+  (progn
+    (set-face-foreground 'modelinepos-column-warning "grey20")
+    (set-face-background 'modelinepos-column-warning "red")
+    (setq modelinepos-column-limit 72))
+  )
 #+END_SRC
+
 **** diminish
 [2013-04-22 Mon 11:27]
 The modeline is easily cluttered up with stuff I don't really need to
@@ -345,9 +386,7 @@ be org-mode - it is just so much better to use. And does sensible things
 with many README files out there, and various other "crap" you get to
 read in emacs.
 #+BEGIN_SRC emacs-lisp :tangle yes
-(if (> emacs-major-version 22)
-  (setq major-mode 'org-mode)
-  (setq default-major-mode 'org-mode))
+(setq major-mode 'org-mode)
 (setq initial-major-mode 'org-mode)
 #+END_SRC
 
@@ -372,31 +411,53 @@ Shell. zsh in my case.
 *** Emacs shell
 Basic settings for emacs integrated shell
 #+BEGIN_SRC emacs-lisp :tangle yes
-(setq eshell-cmpl-cycle-completions nil
-      eshell-save-history-on-exit t
-      eshell-cmpl-dir-ignore "\\`\\(\\.\\.?\\|CVS\\|\\.svn\\|\\.git\\)/\\'")
-(eval-after-load 'esh-opt
-  '(progn
-     (require 'em-cmpl)
-     (require 'em-prompt)
-     (require 'em-term)
-     ;; TODO: for some reason requiring this here breaks it, but
-     ;; requiring it after an eshell session is started works fine.
-     ;; (require 'eshell-vc)
-     (after 'eshell-mode
-       (setenv "PAGER" "cat")
-       (add-to-list 'eshell-visual-commands "ssh")
-       (add-to-list 'eshell-visual-commands "tail")
-       (add-to-list 'eshell-command-completions-alist
-                    '("gunzip" "gz\\'"))
-       (add-to-list 'eshell-command-completions-alist
-                    '("tar" "\\(\\.tar|\\.tgz\\|\\.tar\\.gz\\)\\'")))
-
-     ; (set-face-attribute 'eshell-prompt nil :foreground "turquoise1")
-     (add-hook 'eshell-mode-hook ;; for some reason this needs to be a hook
-               '(lambda () (define-key eshell-mode-map "\C-a" 'eshell-bol)))
-     (add-hook 'eshell-preoutput-filter-functions
-               'ansi-color-filter-apply)))
+(use-package eshell
+  :defer t
+  :init
+  (progn
+    (defun eshell-initialize ()
+      (defun eshell-spawn-external-command (beg end)
+        "Parse and expand any history references in current input."
+        (save-excursion
+          (goto-char end)
+          (when (looking-back "&!" beg)
+            (delete-region (match-beginning 0) (match-end 0))
+            (goto-char beg)
+            (insert "spawn "))))
+
+      (add-hook 'eshell-expand-input-functions 'eshell-spawn-external-command)
+
+      (eval-after-load "em-unix"
+        '(progn
+           (unintern 'eshell/su)
+           (unintern 'eshell/sudo))))
+
+    (add-hook 'eshell-first-time-mode-hook 'eshell-initialize)
+
+    (setq eshell-cmpl-cycle-completions nil
+          eshell-save-history-on-exit t
+          eshell-cmpl-dir-ignore "\\`\\(\\.\\.?\\|CVS\\|\\.svn\\|\\.git\\)/\\'")
+    )
+  :config
+  (progn
+    (require 'em-cmpl)
+    (require 'em-prompt)
+    (require 'em-term)
+
+    (setenv "PAGER" "cat")
+    (add-to-list 'eshell-visual-commands "ssh")
+    (add-to-list 'eshell-visual-commands "tail")
+    (add-to-list 'eshell-command-completions-alist
+                 '("gunzip" "gz\\'"))
+    (add-to-list 'eshell-command-completions-alist
+                 '("tar" "\\(\\.tar|\\.tgz\\|\\.tar\\.gz\\)\\'"))
+
+    ;(set-face-attribute 'eshell-prompt nil :foreground "turquoise1")
+    (add-hook 'eshell-mode-hook ;; for some reason this needs to be a hook
+              '(lambda () (define-key eshell-mode-map "\C-a" 'eshell-bol)))
+    (add-hook 'eshell-preoutput-filter-functions
+              'ansi-color-filter-apply)
+    ))
 #+END_SRC
 
 *** Isearch related
@@ -406,9 +467,9 @@ occurence of what is at your cursor position use the following.
 *C-x* will insert the current word while *M-up* and *M-down* will just
 jump to the next/previous occurence of it.
 #+BEGIN_SRC emacs-lisp :tangle yes
-(define-key isearch-mode-map (kbd "C-x") 'sacha/isearch-yank-current-word)
-(global-set-key '[M-up] 'sacha/search-word-backward)
-(global-set-key '[M-down] 'sacha/search-word-forward)
+(bind-key "C-x" 'sacha/isearch-yank-current-word isearch-mode-map)
+(bind-key* "<M-up>" 'sacha/search-word-backward)
+(bind-key* "<M-down>" 'sacha/search-word-forward)
 #+END_SRC
 
 *** Frame configuration
@@ -423,11 +484,14 @@ I don't want some buffers to be killed, **scratch** for example.
 In the past I had a long function that just recreated them, but the
 =keep-buffers= package is easier.
 #+BEGIN_SRC emacs-lisp :tangle yes
-(require 'keep-buffers)
-(keep-buffers-mode 1)
-(push '("\\`*scratch" . erase) keep-buffers-protected-alist)
-(push '("\\`*Org Agenda" . nil) keep-buffers-protected-alist)
-(push '("\\`*Group" . nil) keep-buffers-protected-alist)
+(use-package keep-buffers
+  :init
+  (progn
+    (keep-buffers-mode 1)
+    (push '("\\`*scratch" . erase) keep-buffers-protected-alist)
+    (push '("\\`*Org Agenda" . nil) keep-buffers-protected-alist)
+    (push '("\\`*Group" . nil) keep-buffers-protected-alist)
+    ))
 #+END_SRC
 
 *** yes-or-no-p
@@ -454,15 +518,25 @@ In this day and age, UTF-8 is the way to go.
 While I do have the nifty shortcut to jump to the other parentheses,
 hilighting them makes it obvious where they are.
 #+BEGIN_SRC emacs-lisp :tangle yes
-(require 'paren)
-(setq show-paren-style 'parenthesis)
-(show-paren-mode +1)
+(unless
+    (use-package mic-paren
+      :init
+      (paren-activate))
+
+  (use-package paren
+    :init
+    (progn
+      (show-paren-mode +1)
+      (setq show-paren-style 'parenthesis)
+      )
+    )
+  )
 #+END_SRC
 *** Kill other buffers
 While many editors allow you to close "all the other files, not the one
 you are in", emacs doesn't have this... Except, now it will.
 #+BEGIN_SRC emacs-lisp :tangle yes
-(global-set-key (kbd "C-c k") 'prelude-kill-other-buffers)
+(bind-key "C-c k" 'prelude-kill-other-buffers)
 #+END_SRC
 *** Scrolling
 Default scrolling behaviour in emacs is a bit annoying, who wants to
@@ -490,8 +564,8 @@ changed in emacs24. I am used to the old way, so get it back.
 *** Global keyboard changes not directly related to a mode
 Disable /suspend_frame/ function, I dislike it.
 #+BEGIN_SRC emacs-lisp :tangle yes
-(global-unset-key [(control z)])
-(global-unset-key [(control x) (control z)])
+(unbind-key "C-z")
+(unbind-key "C-x C-z")
 #+END_SRC
 
 Default of *C-k* is to kill from the point to the end of line. If
@@ -507,8 +581,8 @@ me. Lazyness++.
   (kill-line)
   (back-to-indentation))
 
-(global-unset-key [(control k)])
-(global-set-key [(control k)] 'kill-entire-line)
+(unbind-key "C-z")
+(bind-key* "C-k" 'kill-entire-line)
 (global-set-key [remap kill-whole-line] 'kill-entire-line)
 #+END_SRC
 
@@ -533,73 +607,73 @@ file/project, but luckily none of those I work in is as broken.
 
 Make the % key jump to the matching {}[]() if on another, like vi, see [[id:b6e6cf73-9802-4a7b-bd65-fdb6f9745319][the function]]
 #+BEGIN_SRC emacs-lisp :tangle yes
-(global-set-key "\M-5" 'match-paren)
+(bind-key* "M-5" 'match-paren)
 #+END_SRC
 
 Instead of the default "mark-defun" I want a more readline-like setting.
-#+begin_src emacs-lisp
-(global-set-key (kbd "C-M-h") 'backward-kill-word)
-#+end_src
+#+BEGIN_SRC emacs-lisp :tangle yes
+(bind-key "C-M-h" 'backward-kill-word)
+#+END_SRC
 
 Align whatever with a regexp.
-#+begin_src emacs-lisp
-(global-set-key (kbd "C-x \\") 'align-regexp)
-#+end_src
+#+BEGIN_SRC emacs-lisp :tangle yes
+(bind-key "C-x \\" 'align-regexp)
+#+END_SRC
 
 Font size changes
-#+begin_src emacs-lisp
-(global-set-key (kbd "C-+") 'text-scale-increase)
-(global-set-key (kbd "C--") 'text-scale-decrease)
-#+end_src
+#+BEGIN_SRC emacs-lisp :tangle yes
+(bind-key "C-+" 'text-scale-increase)
+(bind-key "C--" 'text-scale-decrease)
+#+END_SRC
 
 Regexes are too useful, so use the regex search by default.
 #+begin_src emacs-lisp
-(global-set-key (kbd "C-s") 'isearch-forward-regexp)
-(global-set-key (kbd "\C-r") 'isearch-backward-regexp)
-(global-set-key (kbd "C-M-s") 'isearch-forward)
-(global-set-key (kbd "C-M-r") 'isearch-backward)
+(bind-key "C-s"   'isearch-forward-regexp)
+(bind-key "C-r"   'isearch-backward-regexp)
+(bind-key "C-M-s" 'isearch-forward)
+(bind-key "C-M-r" 'isearch-backward)
 #+end_src
 
 Rgrep is infinitely useful in multi-file projects.
 #+begin_src emacs-lisp
-(define-key global-map "\C-x\C-g" 'rgrep)
+(bind-key "C-x C-g" 'rgrep)
 #+end_src
 
 Easy way to move a line up - or down. Simpler than dealing with C-x C-t
 AKA transpose lines.
 #+BEGIN_SRC emacs-lisp :tangle yes
-(global-set-key [(meta shift up)]  'move-line-up)
-(global-set-key [(meta shift down)]  'move-line-down)
+(bind-key "<M-S-up>"  'move-line-up)
+(bind-key "<M-S-down>" 'move-line-down)
 #+END_SRC
 
 "Pull" lines up, join them
 #+BEGIN_SRC emacs-lisp :tangle yes
-(global-set-key (kbd "M-j")
-                (lambda ()
-                  (interactive)
-                  (join-line -1)))
+(bind-key "M-j"
+          (lambda ()
+            (interactive)
+            (join-line -1)))
 #+END_SRC
 
 When I press Enter I almost always want to go to the right indentation on the next line.
 #+BEGIN_SRC emacs-lisp :tangle yes
-(global-set-key (kbd "RET") 'newline-and-indent)
+(bind-key "RET" 'newline-and-indent)
 #+END_SRC
 
 Easier undo, and i don't need suspend-frame
 #+BEGIN_SRC emacs-lisp :tangle yes
-(global-set-key (kbd "C-z") 'undo)
+(bind-key "C-z" 'undo)
 #+END_SRC
 
 Window switching, go backwards. (C-x o goes to the next window)
 #+BEGIN_SRC emacs-lisp :tangle yes
-(global-set-key (kbd "C-x O") (lambda ()
-                                (interactive)
-                                (other-window -1)))
+(bind-key "C-x O" (lambda ()
+                    (interactive)
+                    (other-window -1)))
 #+END_SRC
 
 Edit file as root
 #+BEGIN_SRC emacs-lisp :tangle yes
-(global-set-key (kbd "C-x C-r") 'prelude-sudo-edit)
+(bind-key "C-x C-r" 'prelude-sudo-edit)
 #+END_SRC
 
 M-space is bound to just-one-space, which is great for programming. What
@@ -608,20 +682,19 @@ be really useful, it also should include newlines. It doesn’t do this by
 default. Rather, you have to call it with a negative argument. Sure
 not, bad Emacs.
 #+BEGIN_SRC emacs-lisp :tangle yes
-(global-set-key (kbd "M-SPC") 'just-one-space-with-newline)
+(bind-key "M-SPC" 'just-one-space-with-newline)
 #+END_SRC
 
 Count which commands I use how often.
 #+BEGIN_SRC emacs-lisp :tangle yes
-(defvar keyfreq-file
-  (expand-file-name "keyfreq" jj-cache-dir)
-  "Keyfreq cache file")
-(defvar keyfreq-file-lock
-  (expand-file-name "keyfreq.lock" jj-cache-dir)
-  "Keyfreq cache file")
-(require 'keyfreq)
-(keyfreq-mode 1)
-(keyfreq-autosave-mode 1)
+(use-package keyfreq
+  :ensure keyfreq
+  :init
+  (progn
+    (setq keyfreq-file (expand-file-name "keyfreq" jj-cache-dir))
+    (setq keyfreq-file-lock (expand-file-name "keyfreq.lock" jj-cache-dir))
+    (keyfreq-mode 1)
+    (keyfreq-autosave-mode 1)))
 #+END_SRC
 
 Duplicate current line
@@ -637,7 +710,7 @@ Duplicate current line
       (newline)
       (insert line-text))))
 
-(global-set-key (kbd "C-c p") 'duplicate-line)
+(bind-key "C-c p" 'duplicate-line)
 #+END_SRC
 
 Smarter move to the beginning of the line. That is, it first moves to
@@ -678,33 +751,21 @@ above point. With a prefix argument, only copy ARG characters (never
 past EOL), no argument copies rest of line.
 #+BEGIN_SRC emacs-lisp :tangle yes
 (require 'misc)
-(global-set-key (kbd "H-y") 'copy-from-above-command)
+(bind-key "H-y" 'copy-from-above-command)
 #+END_SRC
 
 Open a new X Terminal pointing to the directory of the current
 buffers path.
 #+BEGIN_SRC emacs-lisp :tangle yes
-(global-set-key (kbd "H-t") 'jj-open-shell)
-#+END_SRC
-**** ace-jump-mode
-[2013-04-28 So 11:26]
-
-Quickly move around in buffers.
-#+BEGIN_SRC emacs-lisp :tangle yes
-(autoload 'ace-jump-mode "ace-jump-mode" "Emacs quick move minor mode" t)
-(define-key global-map (kbd "H-SPC") 'ace-jump-mode)
-;; enable a more powerful jump back function from ace jump mode
-(autoload 'ace-jump-mode-pop-mark "ace-jump-mode" "Ace jump back :-)" t)
-(eval-after-load "ace-jump-mode" '(ace-jump-mode-enable-mark-sync))
-(define-key global-map (kbd "H-c SPC") 'ace-jump-mode-pop-mark)
+(bind-key "H-t" 'jj-open-shell)
 #+END_SRC
 **** Overwrite mode
 Usually you can press the *Ins*ert key, to get into overwrite mode. I
 don't like that, have broken much with it and so just forbid it by
 disabling that.
 #+BEGIN_SRC emacs-lisp :tangle yes
-(global-unset-key [insert])
-(global-unset-key [kp-insert])
+(unbind-key "<insert>")
+(unbind-key "<kp-insert>")
 #+END_SRC
 
 ** Miscellaneous stuff
@@ -734,7 +795,6 @@ where =temporary-file-directory= is not inside my home).
               (let ((method (file-remote-p name 'method)))
                 (when (stringp method)
                   (member method '("su" "sudo"))))))))
-
 #+END_SRC
 
 Weeks start on Monday, not sunday.
@@ -789,6 +849,7 @@ From https://raw.github.com/qdot/conf_emacs/master/emacs_conf.org
   (interactive)
   (let ((fill-column (point-max)))
     (fill-paragraph nil)))
+(bind-key "H-u" 'unfill-paragraph)
 #+END_SRC
 
 #+BEGIN_SRC emacs-lisp :tangle yes
@@ -813,9 +874,10 @@ Hilight annotations in comments, like FIXME/TODO/...
 
 *** Emacs Server
 #+BEGIN_SRC emacs-lisp :tangle yes
-(require 'server)
-(unless (server-running-p)
-  (server-start))
+(use-package server
+  :init
+  (progn
+    (add-hook 'after-init-hook 'server-start)))
 #+END_SRC
 
 ** Customized variables
@@ -824,28 +886,28 @@ The following contains a set of variables i may reasonably want to
 change on other systems - which don't affect the init file loading
 process. So I *can* use the customization interface for it...
 #+BEGIN_SRC emacs-lisp :tangle yes
-  (defgroup ganneff nil
-    "Modify ganneffs settings"
-    :group 'environment)
+(defgroup ganneff nil
+  "Modify ganneffs settings"
+  :group 'environment)
 
-  (defgroup ganneff-org-mode nil
-    "Ganneffs org-mode settings"
-    :tag "Ganneffs org-mode settings"
-    :group 'ganneff
-    :link '(custom-group-link "ganneff"))
+(defgroup ganneff-org-mode nil
+  "Ganneffs org-mode settings"
+  :tag "Ganneffs org-mode settings"
+  :group 'ganneff
+  :link '(custom-group-link "ganneff"))
 
-  (defcustom bh/organization-task-id "d0db0d3c-f22e-42ff-a654-69524ff7cc91"
-    "ID of the organization task."
-    :tag "Organization Task ID"
-    :type 'string
-    :group 'ganneff-org-mode)
+(defcustom bh/organization-task-id "d0db0d3c-f22e-42ff-a654-69524ff7cc91"
+  "ID of the organization task."
+  :tag "Organization Task ID"
+  :type 'string
+  :group 'ganneff-org-mode)
 
-  (defcustom org-my-archive-expiry-days 2
-    "The number of days after which a completed task should be auto-archived.
-  This can be 0 for immediate, or a floating point value."
-    :tag "Archive expiry days"
-    :type 'float
-    :group 'ganneff-org-mode)
+(defcustom org-my-archive-expiry-days 2
+  "The number of days after which a completed task should be auto-archived.
+This can be 0 for immediate, or a floating point value."
+  :tag "Archive expiry days"
+  :type 'float
+  :group 'ganneff-org-mode)
 #+END_SRC
 
 
@@ -876,20 +938,34 @@ The source of this is:
 
 
 * Extra modes and their configuration
-** mode alists
-For some file endings we need to tell emacs what mode we want for them.
-I only list modes here where I don't have any other special
-configuration.
-
-- Markdown syntax
+** ace-jump-mode
+[2013-04-28 So 11:26]
+Quickly move around in buffers.
 #+BEGIN_SRC emacs-lisp :tangle yes
-(add-auto-mode 'markdown-mode "\\.mdwn$")
+(use-package ace-jump-mode
+  :ensure ace-jump-mode
+  :command ace-jump-mode
+  :bind ("H-SPC" . ace-jump-mode))
 #+END_SRC
-
-- diff
+** markdown-mode
+[2014-05-20 Tue 23:04]
+#+BEGIN_SRC emacs-lisp :tangle yes
+(use-package markdown-mode
+  :mode (("\\.md\\'" . markdown-mode)
+         ("\\.mdwn\\'" . markdown-mode))
+  :defer t)
+#+END_SRC
+** diff-mode
 #+BEGIN_SRC emacs-lisp :tangle yes
-(add-auto-mode 'diff-mode "COMMIT_EDITMSG$")
+(use-package diff-mode
+  :commands diff-mode
+  :mode ("COMMIT_EDITMSG$" . diff-mode)
+  :config
+  (use-package diff-mode-))
 #+END_SRC
+For some file endings we need to tell emacs what mode we want for them.
+I only list modes here where I don't have any other special
+configuration.
 
 ** Region bindings mode
 [2013-05-01 Wed 22:51]
@@ -897,22 +973,29 @@ This mode allows to have keybindings that are only alive when the
 region is active. Helpful for things that only do any useful action
 then, like for example the [[*multiple%20cursors][multiple cursors]] mode I load later.
 #+BEGIN_SRC emacs-lisp :tangle yes
-(require 'region-bindings-mode)
-(region-bindings-mode-enable)
+(use-package region-bindings-mode
+  :ensure region-bindings-mode
+  :init
+  (region-bindings-mode-enable))
 #+END_SRC
 ** tramp
 Transparent Remote (file) Access, Multiple Protocol, remote file editing.
 #+BEGIN_SRC emacs-lisp :tangle yes
-(require 'tramp)
-(setq tramp-default-method "ssh")
-(setq tramp-persistency-file-name (expand-file-name "tramp" jj-cache-dir))
-(setq shell-prompt-pattern "^[^a-zA-Z].*[#$%>] *")
-(add-to-list 'tramp-default-method-alist
-                         '("\\`localhost\\'" "\\`root\\'" "su")
-                         )
-(setq tramp-debug-buffer nil)
-(setq tramp-default-method "sshx")
-(setq tramp-verbose 5)
+(use-package tramp
+  :defer t
+  :config
+  (progn
+    (setq tramp-persistency-file-name (expand-file-name "tramp" jj-cache-dir))
+    (setq shell-prompt-pattern "^[^a-zA-Z].*[#$%>] *")
+    (add-to-list 'tramp-default-method-alist '("\\`localhost\\'" "\\`root\\'" "su")
+                 )
+    (setq tramp-debug-buffer nil)
+    (setq tramp-default-method "sshx")
+    (tramp-set-completion-function "ssh"
+                                   '((tramp-parse-sconfig "/etc/ssh_config")
+                                     (tramp-parse-sconfig "~/.ssh/config")))
+    (setq tramp-verbose 5)
+    ))
 #+END_SRC
 
 ** tiny-tools
@@ -936,14 +1019,11 @@ them. I don't need much actually, but these things are nice to have.
 #+END_SRC
 *** Keyboard changes for tiny-tools
 #+BEGIN_SRC emacs-lisp :tangle yes
-(global-set-key  "\M-;" 'tinycomment-indent-for-comment)
-
-(global-set-key (kbd "ESC C-k")       'tinyeat-kill-line-backward)
-(global-set-key (kbd "ESC d")         'tinyeat-forward-preserve)
-(global-set-key (kbd "ESC z")         'tinyeat-kill-buffer-lines-main)
-(global-set-key (kbd "<M-backspace>") 'tinyeat-backward-preserve)
-(global-set-key (kbd "<C-delete>")    'tinyeat-forward-preserve)
-(global-set-key (kbd "<S-backspace>") 'tinyeat-delete-whole-word)
+(bind-key  "\M-;" 'tinycomment-indent-for-comment)
+(bind-key "ESC C-k"       'tinyeat-kill-line-backward)
+(bind-key "ESC d"         'tinyeat-forward-preserve)
+(bind-key "<M-backspace>" 'tinyeat-backward-preserve)
+(bind-key "<S-backspace>" 'tinyeat-delete-whole-word)
 #+END_SRC
 
 ** dired & co
@@ -951,80 +1031,152 @@ I like dired and work a lot with it, but it tends to leave lots of
 windows around.
 dired-single to the rescue.
 #+BEGIN_SRC emacs-lisp :tangle yes
-(require 'dired)
-(autoload 'dired-single-buffer "dired-single" "" t)
-(autoload 'dired-single-buffer-mouse "dired-single" "" t)
-(autoload 'dired-single-magic-buffer "dired-single" "" t)
-(autoload 'dired-single-toggle-buffer-name "dired-single" "" t)
-#+END_SRC
-
-wdired
-#+BEGIN_SRC emacs-lisp :tangle yes
-(autoload 'wdired-change-to-wdired-mode "wdired")
-(setq wdired-allow-to-change-permissions t)
-(define-key dired-mode-map "r" 'wdired-change-to-wdired-mode)
-#+END_SRC
-
-We want some extra key bindings loaded. In case we haven't loaded dired
-yet, there won't be a keymap to add to, so add our setup function to the
-load hook only. Otherwise just bind the keys.
-#+BEGIN_SRC emacs-lisp :tangle yes
-(define-key dired-mode-map
-  [menu-bar immediate wdired-change-to-wdired-mode]
-  '("Edit File Names" . wdired-change-to-wdired-mode))
-(define-key dired-mode-map [return] 'dired-single-buffer)
-(define-key dired-mode-map [mouse-1] 'dired-single-buffer-mouse)
-(define-key dired-mode-map "^"
-  (function
-   (lambda nil (interactive) (dired-single-buffer ".."))))
-#+END_SRC
-
-A few settings
-#+BEGIN_SRC emacs-lisp :tangle yes
-(setq dired-auto-revert-buffer (quote dired-directory-changed-p))
-(setq dired-dwim-target t)
-(setq dired-listing-switches "-alh")
-(setq dired-recursive-copies (quote top))
-(setq dired-recursive-deletes (quote top))
-#+END_SRC
+(use-package dired
+  :defer t
+  :init
+  (progn
+    (defvar mark-files-cache (make-hash-table :test #'equal))
+
+    (defun mark-similar-versions (name)
+      (let ((pat name))
+        (if (string-match "^\\(.+?\\)-[0-9._-]+$" pat)
+            (setq pat (match-string 1 pat)))
+        (or (gethash pat mark-files-cache)
+            (ignore (puthash pat t mark-files-cache)))))
+
+    (defun dired-mark-similar-version ()
+      (interactive)
+      (setq mark-files-cache (make-hash-table :test #'equal))
+      (dired-mark-sexp '(mark-similar-versions name))))
+  :config
+  (progn
+    (setq dired-auto-revert-buffer (quote dired-directory-changed-p))
+    (setq dired-dwim-target t)
+    (setq dired-listing-switches "-alh")
+    (setq dired-recursive-copies (quote top))
+    (setq dired-recursive-deletes (quote top))
+
+    (defun dired-package-initialize ()
+      (unless (featurep 'runner)
+        (use-package dired-x)
+        (use-package runner
+          :ensure runner)
+
+        (use-package dired-single
+          :ensure dired-single
+          :init
+          (progn
+            (bind-key "<return>" 'dired-single-buffer dired-mode-map)
+            (bind-key "<mouse-1>" 'dired-single-buffer-mouse dired-mode-map)
+            (bind-key "^"
+              (function
+               (lambda nil (interactive) (dired-single-buffer ".."))) dired-mode-map )))
+
+        (use-package wdired
+          :ensure wdired
+          :init
+          (progn
+            (setq wdired-allow-to-change-permissions t)
+            (bind-key "r" 'wdired-change-to-wdired-mode dired-mode-map)))
+
+        (use-package gnus-dired
+          :init
+          (progn
+            (require 'gnus-dired)
+            (add-hook 'dired-mode-hook 'turn-on-gnus-dired-mode)
+            (bind-key "a" 'gnus-dired-attach dired-mode-map)))
+
+        (bind-key "M-!" 'async-shell-command dired-mode-map)
+        (unbind-key "M-s f" dired-mode-map)
+
+        (defadvice dired-omit-startup (after diminish-dired-omit activate)
+          "Make sure to remove \"Omit\" from the modeline."
+          (diminish 'dired-omit-mode) dired-mode-map)
+
+        ;; Omit files that Git would ignore
+        (defun dired-omit-regexp ()
+          (let ((file (expand-file-name ".git"))
+                parent-dir)
+            (while (and (not (file-exists-p file))
+                        (progn
+                          (setq parent-dir
+                                (file-name-directory
+                                 (directory-file-name
+                                  (file-name-directory file))))
+                          ;; Give up if we are already at the root dir.
+                          (not (string= (file-name-directory file)
+                                        parent-dir))))
+              ;; Move up to the parent dir and try again.
+              (setq file (expand-file-name ".git" parent-dir)))
+            ;; If we found a change log in a parent, use that.
+            (if (file-exists-p file)
+                (let ((regexp (funcall dired-omit-regexp-orig))
+                      (omitted-files
+                       (shell-command-to-string "git clean -d -x -n")))
+                  (if (= 0 (length omitted-files))
+                      regexp
+                    (concat
+                     regexp
+                     (if (> (length regexp) 0)
+                         "\\|" "")
+                     "\\("
+                     (mapconcat
+                      #'(lambda (str)
+                          (concat
+                           "^"
+                           (regexp-quote
+                            (substring str 13
+                                       (if (= ?/ (aref str (1- (length str))))
+                                           (1- (length str))
+                                         nil)))
+                           "$"))
+                      (split-string omitted-files "\n" t)
+                      "\\|")
+                     "\\)")))
+              (funcall dired-omit-regexp-orig))))))
+
+    (add-hook 'dired-mode-hook 'dired-package-initialize)
+
+    (defun dired-double-jump (first-dir second-dir)
+      (interactive
+       (list (read-directory-name "First directory: "
+                                  (expand-file-name "~")
+                                  nil nil "dl/")
+             (read-directory-name "Second directory: "
+                                  (expand-file-name "~")
+                                  nil nil "Archives/")))
+      (dired first-dir)
+      (dired-other-window second-dir))
+    (bind-key "C-c J" 'dired-double-jump)))
 
-and gnus-dired makes it easy to attach files
-#+BEGIN_SRC emacs-lisp :tangle yes
-(eval-after-load "gnus"
-  '(progn
-     (require 'gnus-dired)
-     (add-hook 'dired-mode-hook 'turn-on-gnus-dired-mode)
-     (define-key dired-mode-map "a" 'gnus-dired-attach)))
 #+END_SRC
 
 ** filladapt
 [2013-05-02 Thu 00:04]
 #+BEGIN_SRC emacs-lisp :tangle yes
-(require 'filladapt)
-(eval-after-load "filladapt" '(diminish 'filladapt-mode))
-(setq-default filladapt-mode t)
-#+END_SRC
-** ffap
-[2013-05-03 Fri 16:09]
-Replace default find-file with find-file-at-point, which tries to
-guess the default file/URL from text around the point.
-#+BEGIN_SRC emacs-lisp :tangle yes
-(ffap-bindings)
+(use-package filladapt
+  :diminish filladapt-mode
+  :init
+  (setq-default filladapt-mode t))
 #+END_SRC
 ** icicles
 [[http://article.gmane.org/gmane.emacs.orgmode/4574/match%3Dicicles]["In case you never heard of it, Icicles is to ‘TAB’ completion what
 ‘TAB’ completion is to typing things manually every time.”]]
 #+BEGIN_SRC emacs-lisp :tangle yes
-(require 'icicles)
-(icy-mode 1)
+(use-package icicles
+  :load-path "elisp/icicle/"
+  :init
+  (icy-mode 1))
 #+END_SRC
 ** uniquify
 Always have unique buffernames. See [[http://www.gnu.org/software/emacs/manual/html_node/emacs/Uniquify.html][Uniquify - GNU Emacs Manual]]
 #+BEGIN_SRC emacs-lisp :tangle yes
-(require 'uniquify)
-(setq uniquify-buffer-name-style 'post-forward)
-(setq uniquify-after-kill-buffer-p t)
-(setq uniquify-ignore-buffers-re "^\\*")
+(use-package uniquify
+  :init
+  (progn
+    (setq uniquify-buffer-name-style 'post-forward)
+    (setq uniquify-after-kill-buffer-p t)
+    (setq uniquify-ignore-buffers-re "^\\*")))
 #+END_SRC
 
 ** abbrev
@@ -1032,11 +1184,23 @@ A defined abbrev is a word which expands, if you insert it, into some
 different text. Abbrevs are defined by the user to expand in specific
 ways.
 #+BEGIN_SRC emacs-lisp :tangle yes
-(setq save-abbrevs 'silently)
-(setq abbrev-file-name (expand-file-name "abbrev_defs" jj-cache-dir))
-(if (file-exists-p abbrev-file-name)
-    (quietly-read-abbrev-file))
-(abbrev-mode 1)
+(use-package abbrev
+  :commands abbrev-mode
+  :diminish abbrev-mode
+  :init
+  (hook-into-modes #'abbrev-mode '(text-mode-hook))
+
+  :config
+  (progn
+    (setq save-abbrevs 'silently)
+    (setq abbrev-file-name (expand-file-name "abbrev_defs" jj-cache-dir))
+    (if (file-exists-p abbrev-file-name)
+        (quietly-read-abbrev-file))
+
+    (add-hook 'expand-load-hook
+              (lambda ()
+                (add-hook 'expand-expand-hook 'indent-according-to-mode)
+                (add-hook 'expand-jump-hook 'indent-according-to-mode)))))
 #+END_SRC
 
 ** font-lock
@@ -1044,15 +1208,24 @@ Obviously emacs can do syntax hilighting. For more things than you ever
 heard about.
 And I want to have it everywhere.
 #+BEGIN_SRC emacs-lisp :tangle yes
-(require 'font-lock)
-(global-font-lock-mode 1)
-(setq font-lock-maximum-decoration t)
+(use-package font-lock
+  :init
+  (progn
+    (global-font-lock-mode 1)
+    (setq font-lock-maximum-decoration t)))
 #+END_SRC
 ** miniedit
 Edit minibuffer in a full (text-mode) buffer by pressing *M-C-e*.
 #+BEGIN_SRC emacs-lisp :tangle yes
-(require 'miniedit)
-(miniedit-install)
+(use-package miniedit
+  :ensure miniedit
+  :config
+  (progn
+    (bind-key "M-C-e" 'miniedit minibuffer-local-map)
+    (bind-key "M-C-e" 'miniedit minibuffer-local-ns-map)
+    (bind-key "M-C-e" 'miniedit minibuffer-local-completion-map)
+    (bind-key "M-C-e" 'miniedit minibuffer-local-must-match-map)
+  ))
 #+END_SRC
 
 ** timestamp
@@ -1061,68 +1234,121 @@ formats if one exists in the first 8 lines of the file.
 - Time-stamp: <>
 - Time-stamp: " "
 #+BEGIN_SRC emacs-lisp :tangle yes
-(require 'time-stamp)
-(setq time-stamp-active t)
-(setq time-stamp-format "%02H:%02M:%02S (%z) - %02d.%02m.%:y from %u (%U) on %s")
-(setq time-stamp-old-format-warn nil)
-(setq time-stamp-time-zone nil)
-(add-hook 'write-file-hooks 'time-stamp)
+(use-package time-stamp
+  :commands time-stamp
+  :init
+  (progn
+    (add-hook 'write-file-hooks 'time-stamp)
+    (setq time-stamp-active t))
+  :config
+  (progn
+    (setq time-stamp-format "%02H:%02M:%02S (%z) - %02d.%02m.%:y from %u (%U) on %s")
+    (setq time-stamp-old-format-warn nil)
+    (setq time-stamp-time-zone nil)))
 #+END_SRC
 
 ** perl / cperl
 I like /cperl-mode/ a bit more than the default /perl-mode/, so set it
 up here to be used.
 #+BEGIN_SRC emacs-lisp :tangle yes
-(autoload 'cperl-mode "cperl-mode" )
-(defalias 'perl-mode 'cperl-mode)
-(add-auto-mode 'cperl-mode "\\.\\([pP][Llm]\\|al\\)\\'")
-(add-auto-mode 'pod-mode   "\\.pod$")
-(add-auto-mode 'tt-mode    "\\.tt$")
-(add-to-list 'interpreter-mode-alist '("perl" . cperl-mode))
-(add-to-list 'interpreter-mode-alist '("perl5" . cperl-mode))
-(add-to-list 'interpreter-mode-alist '("miniperl" . cperl-mode))
-
-(after 'cperl-mode
-  (setq cperl-hairy t)
-  (setq cperl-electric-keywords t)
-  (setq cperl-electric-lbrace-space t)
-  (setq cperl-electric-parens nil)
-  (setq cperl-highlight-variables-indiscriminately t)
-  (setq cperl-imenu-addback t)
-  (setq cperl-invalid-face (quote underline))
-  (setq cperl-lazy-help-time 5)
-  (setq cperl-mode-hook (quote (turn-on-tinyperl-mode)))
-  (setq cperl-scan-files-regexp "\\.\\([pP][Llm]\\|xs\\|cgi\\)$")
-  (setq cperl-syntaxify-by-font-lock t)
-  (setq cperl-use-syntax-table-text-property-for-tags t)
-
-  ;; And have cperl mode give ElDoc a useful string
-  (defun my-cperl-eldoc-documentation-function ()
-    "Return meaningful doc string for `eldoc-mode'."
-    (car
-     (let ((cperl-message-on-help-error nil))
-       (cperl-get-help))))
-
-  (add-hook 'cperl-mode-hook
-            (lambda ()
-              (set (make-local-variable 'eldoc-documentation-function)
-                   'my-cperl-eldoc-documentation-function)
-              (eldoc-mode))))
+(use-package perl-mode
+  :commands cperl-mode
+  :init
+  (progn
+    (defalias 'perl-mode 'cperl-mode)
+    (add-auto-mode 'cperl-mode "\\.\\([pP][Llm]\\|al\\)\\'")
+    (add-auto-mode 'pod-mode   "\\.pod$")
+    (add-auto-mode 'tt-mode    "\\.tt$")
+    (add-to-list 'interpreter-mode-alist '("perl" . cperl-mode))
+    (add-to-list 'interpreter-mode-alist '("perl5" . cperl-mode))
+    (add-to-list 'interpreter-mode-alist '("miniperl" . cperl-mode))
+    )
+  :config
+  (progn
+    (setq cperl-invalid-face nil
+          cperl-close-paren-offset -4
+          cperl-continued-statement-offset 0
+          cperl-indent-level 4
+          cperl-indent-parens-as-block t
+          cperl-hairy t
+          cperl-electric-keywords t
+          cperl-electric-lbrace-space t
+          cperl-electric-parens nil
+          cperl-highlight-variables-indiscriminately t
+          cperl-imenu-addback t
+          cperl-invalid-face (quote underline)
+          cperl-lazy-help-time 5
+          cperl-scan-files-regexp "\\.\\([pP][Llm]\\|xs\\|cgi\\)$"
+          cperl-syntaxify-by-font-lock t
+          cperl-use-syntax-table-text-property-for-tags t)
+
+    ;; And have cperl mode give ElDoc a useful string
+    (defun my-cperl-eldoc-documentation-function ()
+      "Return meaningful doc string for `eldoc-mode'."
+      (car
+       (let ((cperl-message-on-help-error nil))
+         (cperl-get-help))))
+    (add-hook 'cperl-mode-hook
+              (lambda ()
+                (set (make-local-variable 'eldoc-documentation-function)
+                     'my-cperl-eldoc-documentation-function)
+                (eldoc-mode))))
+  )
 #+END_SRC
+** info stuff
+[2014-05-20 Tue 23:35]
+#+BEGIN_SRC emacs-lisp :tangle yes
+(use-package info
+  :bind ("C-h C-i" . info-lookup-symbol)
+  
+  :config
+  (progn
+    ;; (defadvice info-setup (after load-info+ activate)
+    ;;   (use-package info+))
 
+    (defadvice Info-exit (after remove-info-window activate)
+      "When info mode is quit, remove the window."
+      (if (> (length (window-list)) 1)
+          (delete-window)))))
+
+(use-package info-look
+  :commands info-lookup-add-help)
+#+END_SRC
 ** sh
-I prefer comments to be indented too
+Settings for shell scripts
 #+BEGIN_SRC emacs-lisp :tangle yes
-(setq sh-indent-comment t)
-#+END_SRC
+(use-package sh-script
+  :defer t
+  :config
+  (progn
+    (defvar sh-script-initialized nil)
+    (defun initialize-sh-script ()
+      (unless sh-script-initialized
+        (setq sh-script-initialized t)
+        (setq sh-indent-comment t)
+        (info-lookup-add-help :mode 'shell-script-mode
+                              :regexp ".*"
+                              :doc-spec
+                              '(("(bash)Index")))))
 
+    (add-hook 'shell-mode-hook 'initialize-sh-script)))
+#+END_SRC
+** sh-toggle
+#+BEGIN_SRC emacs-lisp :tangle yes
+(use-package sh-toggle
+  :bind ("C-. C-z" . shell-toggle))
+#+END_SRC
 ** auto-revert
 When files change outside emacs for whatever reason I want emacs to deal
 with it. Not to have to revert buffers myself
 #+BEGIN_SRC emacs-lisp :tangle yes
-(require 'autorevert)
-(setq global-auto-revert-mode t)
-(global-auto-revert-mode)
+(use-package autorevert
+  :commands auto-revert-mode
+  :diminish auto-revert-mode
+  :init
+  (progn
+    (setq global-auto-revert-mode t)
+    (global-auto-revert-mode)))
 #+END_SRC
 
 ** linum (line number)
@@ -1131,42 +1357,50 @@ Various modes should have line numbers in front of each line.
 But then there are some where it would just be deadly - like org-mode,
 gnus, so we have a list of modes where we don't want to see it.
 #+BEGIN_SRC emacs-lisp :tangle yes
-(require 'linum)
-(setq linum-format "%3d ")
-(setq linum-mode-inhibit-modes-list '(org-mode
-                                      eshell-mode
-                                      shell-mode
-                                      gnus-group-mode
-                                      gnus-summary-mode
-                                      gnus-article-mode))
-
-(defadvice linum-on (around linum-on-inhibit-for-modes)
-  "Stop the load of linum-mode for some major modes."
-    (unless (member major-mode linum-mode-inhibit-modes-list)
-      ad-do-it))
-
-(ad-activate 'linum-on)
-(global-linum-mode 1)
+(use-package linum
+  :diminish linum-mode
+  :config
+  (progn
+    (setq linum-format "%3d ")
+    (setq linum-mode-inhibit-modes-list '(org-mode
+                                          eshell-mode
+                                          shell-mode
+                                          gnus-group-mode
+                                          gnus-summary-mode
+                                          gnus-article-mode))
+
+    (defadvice linum-on (around linum-on-inhibit-for-modes)
+      "Stop the load of linum-mode for some major modes."
+      (unless (member major-mode linum-mode-inhibit-modes-list)
+        ad-do-it))
+
+    (ad-activate 'linum-on))
+  :init
+  (global-linum-mode 1))
 #+END_SRC
 
 ** css
 #+BEGIN_SRC emacs-lisp :tangle yes
-(autoload 'css-mode "css-mode")
-(add-auto-mode 'css-mode "\\.css")
-
-(after 'css-mode
+(use-package css-mode
+  :mode ("\\.css\\'" . css-mode)
+  :defer t
+  :config
+  (progn
   ;;; CSS flymake
-  (require 'flymake-css)
-  (defun maybe-flymake-css-load ()
-    "Activate flymake-css as necessary, but not in derived modes."
-    (when (eq major-mode 'css-mode)
-      (flymake-css-load)))
-  (add-hook 'css-mode-hook 'maybe-flymake-css-load)
-  ;;; Auto-complete CSS keywords
-  (eval-after-load 'auto-complete
-    '(progn
-       (dolist (hook '(css-mode-hook sass-mode-hook scss-mode-hook))
-         (add-hook hook 'ac-css-mode-setup)))))
+    (use-package flymake-css
+      :ensure flymake-css
+      :config
+      (progn
+        (defun maybe-flymake-css-load ()
+          "Activate flymake-css as necessary, but not in derived modes."
+          (when (eq major-mode 'css-mode)
+            (flymake-css-load)))
+        (add-hook 'css-mode-hook 'maybe-flymake-css-load)))
+    ;;; Auto-complete CSS keywords
+    (eval-after-load 'auto-complete
+      '(progn
+         (dolist (hook '(css-mode-hook sass-mode-hook scss-mode-hook))
+           (add-hook hook 'ac-css-mode-setup))))))
 #+END_SRC
 
 ** mmm-mode
@@ -1174,37 +1408,39 @@ gnus, so we have a list of modes where we don't want to see it.
 MMM Mode is a minor mode for Emacs that allows Multiple Major Modes to
 coexist in one buffer.
 #+BEGIN_SRC emacs-lisp :tangle yes
-(require 'mmm-auto)
-(setq mmm-global-mode 'buffers-with-submode-classes)
-(setq mmm-submode-decoration-level 2)
-(eval-after-load 'mmm-vars
-  '(progn
-     (mmm-add-group
-      'html-css
-      '((css-cdata
-         :submode css-mode
-         :face mmm-code-submode-face
-         :front "<style[^>]*>[ \t\n]*\\(//\\)?<!\\[CDATA\\[[ \t]*\n?"
-         :back "[ \t]*\\(//\\)?]]>[ \t\n]*</style>"
-         :insert ((?j js-tag nil @ "<style type=\"text/css\">"
-                      @ "\n" _ "\n" @ "</script>" @)))
-        (css
-         :submode css-mode
-         :face mmm-code-submode-face
-         :front "<style[^>]*>[ \t]*\n?"
-         :back "[ \t]*</style>"
-         :insert ((?j js-tag nil @ "<style type=\"text/css\">"
-                      @ "\n" _ "\n" @ "</style>" @)))
-        (css-inline
-         :submode css-mode
-         :face mmm-code-submode-face
-         :front "style=\""
-         :back "\"")))
-     (dolist (mode (list 'html-mode 'nxml-mode))
-       (mmm-add-mode-ext-class mode "\\.r?html\\(\\.erb\\)?\\'" 'html-css))
-    (mmm-add-mode-ext-class 'html-mode "\\.php\\'" 'html-php)
-    ))
-
+(use-package mmm-auto
+  :ensure mmm-mode
+  :init
+  (progn
+    (setq mmm-global-mode 'buffers-with-submode-classes)
+    (setq mmm-submode-decoration-level 2)
+    (eval-after-load 'mmm-vars
+      '(progn
+         (mmm-add-group
+          'html-css
+          '((css-cdata
+             :submode css-mode
+             :face mmm-code-submode-face
+             :front "<style[^>]*>[ \t\n]*\\(//\\)?<!\\[CDATA\\[[ \t]*\n?"
+             :back "[ \t]*\\(//\\)?]]>[ \t\n]*</style>"
+             :insert ((?j js-tag nil @ "<style type=\"text/css\">"
+                          @ "\n" _ "\n" @ "</script>" @)))
+            (css
+             :submode css-mode
+             :face mmm-code-submode-face
+             :front "<style[^>]*>[ \t]*\n?"
+             :back "[ \t]*</style>"
+             :insert ((?j js-tag nil @ "<style type=\"text/css\">"
+                          @ "\n" _ "\n" @ "</style>" @)))
+            (css-inline
+             :submode css-mode
+             :face mmm-code-submode-face
+             :front "style=\""
+             :back "\"")))
+         (dolist (mode (list 'html-mode 'nxml-mode))
+           (mmm-add-mode-ext-class mode "\\.r?html\\(\\.erb\\)?\\'" 'html-css))
+         (mmm-add-mode-ext-class 'html-mode "\\.php\\'" 'html-php)
+         ))))
 #+END_SRC
 
 ** html-helper
@@ -2311,8 +2547,13 @@ This is [[https://github.com/mbunkus/mo-git-blame][mo-git-blame -- An interactiv
 Emacs]].
 
 #+BEGIN_SRC emacs-lisp :tangle yes
-(autoload 'mo-git-blame-file "mo-git-blame" nil t)
-(autoload 'mo-git-blame-current "mo-git-blame" nil t)
+(use-package mo-git-blame
+  :ensure mo-git-blame
+  :commands (mo-git-blame-current
+             mo-git-blame-file)
+  :config
+  (progn
+    (setq mo-git-blame-blame-window-width 25)))
 #+END_SRC
 
 ** mingus
@@ -2320,16 +2561,18 @@ Emacs]].
 
 I want to access it from anywhere using =F6=.
 #+BEGIN_SRC emacs-lisp :tangle yes
-(autoload 'mingus "mingus-stays-home" nil t)
-(global-set-key (kbd "<f6>") 'mingus)
-(after 'mingus
- (setq mingus-dired-add-keys t)
- (setq mingus-mode-always-modeline nil)
- (setq mingus-mode-line-show-elapsed-percentage nil)
- (setq mingus-mode-line-show-volume nil)
- (setq mingus-mpd-config-file "/etc/mpd.conf")
- (setq mingus-mpd-playlist-dir "/var/lib/mpd/playlists")
- (setq mingus-mpd-root "/share/music/"))
+(use-package mingus-stays-home
+  :bind ( "<f6>" . mingus)
+  :defer t
+  :config
+  (progn
+    (setq mingus-dired-add-keys t)
+    (setq mingus-mode-always-modeline nil)
+    (setq mingus-mode-line-show-elapsed-percentage nil)
+    (setq mingus-mode-line-show-volume nil)
+    (setq mingus-mpd-config-file "/etc/mpd.conf")
+    (setq mingus-mpd-playlist-dir "/var/lib/mpd/playlists")
+    (setq mingus-mpd-root "/share/music/")))
 #+END_SRC
 
 ** recentf
@@ -2358,7 +2601,7 @@ files. This list is is automatically saved across Emacs sessions.
 
     (add-hook 'dired-mode-hook 'recentf-add-dired-directory)))
 #+END_SRC
-** sessions
+** sessions                                                          :FIXME:
 [2013-05-22 Wed 22:40]
 Save and restore the desktop
 #+BEGIN_SRC emacs-lisp :tangle yes
@@ -2368,34 +2611,75 @@ Save and restore the desktop
   (let ((debug-on-error t))
     ad-do-it))
 
-
 ;;----------------------------------------------------------------------------
 ;; Restore histories and registers after saving
 ;;----------------------------------------------------------------------------
-(require 'session)
-
-(setq session-save-file (expand-file-name "session" jj-cache-dir))
-(add-hook 'after-init-hook 'session-initialize)
-
-;; save a bunch of variables to the desktop file
-;; for lists specify the len of the maximal saved data also
-(setq desktop-globals-to-save
-      (append '((extended-command-history . 30)
-                (file-name-history        . 100)
-                (grep-history             . 30)
-                (compile-history          . 30)
-                (minibuffer-history       . 50)
-                (query-replace-history    . 60)
-                (read-expression-history  . 60)
-                (regexp-history           . 60)
-                (regexp-search-ring       . 20)
-                (search-ring              . 20)
-                (comint-input-ring        . 50)
-                (shell-command-history    . 50)
-                kill-ring
-                desktop-missing-file-warning
-                tags-file-name
-                register-alist)))
+(use-package session
+  :if (not noninteractive)
+  :load-path "site-lisp/session/lisp/"
+  :init
+  (progn
+    (setq session-save-file (expand-file-name "session" jj-cache-dir))
+    (setq desktop-globals-to-save
+          (append '((extended-command-history . 30)
+                    (file-name-history        . 100)
+                    (grep-history             . 30)
+                    (compile-history          . 30)
+                    (minibuffer-history       . 50)
+                    (query-replace-history    . 60)
+                    (read-expression-history  . 60)
+                    (regexp-history           . 60)
+                    (regexp-search-ring       . 20)
+                    (search-ring              . 20)
+                    (comint-input-ring        . 50)
+                    (shell-command-history    . 50)
+                    kill-ring
+                    desktop-missing-file-warning
+                    tags-file-name
+                    register-alist)))
+
+    (session-initialize)
+
+    (defun remove-session-use-package-from-settings ()
+      (when (string= (file-name-nondirectory (buffer-file-name)) "settings.el")
+        (save-excursion
+          (goto-char (point-min))
+          (when (re-search-forward "^ '(session-use-package " nil t)
+            (delete-region (line-beginning-position)
+                           (1+ (line-end-position)))))))
+
+    (add-hook 'before-save-hook 'remove-session-use-package-from-settings)
+
+    ;; expanded folded secitons as required
+    (defun le::maybe-reveal ()
+      (when (and (or (memq major-mode  '(org-mode outline-mode))
+                     (and (boundp 'outline-minor-mode)
+                          outline-minor-mode))
+                 (outline-invisible-p))
+        (if (eq major-mode 'org-mode)
+            (org-reveal)
+          (show-subtree))))
+
+    (add-hook 'session-after-jump-to-last-change-hook
+              'le::maybe-reveal)
+
+    (defun save-information ()
+      (with-temp-message "Saving Emacs information..."
+        (recentf-cleanup)
+
+        (loop for func in kill-emacs-hook
+              unless (memq func '(exit-gnus-on-exit server-force-stop))
+              do (funcall func))
+
+        (unless (or noninteractive
+                    running-alternate-emacs
+                    (eq 'listen (process-status server-process)))
+          (server-start))))
+
+    (run-with-idle-timer 300 t 'save-information)
+
+    (if window-system
+        (add-hook 'after-init-hook 'session-initialize t))))
 
 #+END_SRC
 *** savehist
@@ -2418,6 +2702,7 @@ Store at which point I have been in files.
 (require 'saveplace)
 (setq save-place-file (expand-file-name "saved-places" jj-cache-dir))
 #+END_SRC
+
 ** easypg
 EasyPG is a GnuPG interface for Emacs.
 #+BEGIN_SRC emacs-lisp :tangle yes
@@ -2448,9 +2733,7 @@ I took the following from [[http://www.emacswiki.org/emacs/EasyPG][EmacsWiki: Ea
 Most of my gnus config is in an own file, [[file:gnus.org][gnus.org]], here I only have
 what I want every emacs to know.
 #+BEGIN_SRC emacs-lisp :tangle yes
-;;*** Keyboardmacros
-(global-unset-key "\M-n")
-(global-set-key "\M-n" 'gnus) ; Start gnus with M-n
+(bind-key* "\M-n" 'gnus) ; Start gnus with M-n
 (after 'gnus
   (jj-init-theme)
 )
@@ -2468,17 +2751,20 @@ operating system or location info.
 Crazy way of completion. It looks at the word before point and then
 tries to expand it in various ways.
 #+BEGIN_SRC emacs-lisp :tangle yes
-(require 'hippie-exp)
-(setq hippie-expand-try-functions-list '(try-expand-dabbrev
-                                         try-expand-dabbrev-all-buffers
-                                         try-expand-dabbrev-from-kill
-                                         try-complete-file-name-partially
-                                         try-complete-file-name
-                                         try-expand-all-abbrevs try-expand-list
-                                         try-expand-line
-                                         try-complete-lisp-symbol-partially
-                                         try-complete-lisp-symbol))
-(global-set-key (kbd "M-/") 'hippie-expand)
+(use-package hippie-exp
+  :defer t
+  :bind ("M-/" . hippie-expand)
+  :init
+  (progn
+    (setq hippie-expand-try-functions-list '(try-expand-dabbrev
+                                             try-expand-dabbrev-all-buffers
+                                             try-expand-dabbrev-from-kill
+                                             try-complete-file-name-partially
+                                             try-complete-file-name
+                                             try-expand-all-abbrevs try-expand-list
+                                             try-expand-line
+                                             try-complete-lisp-symbol-partially
+                                             try-complete-lisp-symbol))))
 #+END_SRC
 ** yasnippet
 [2013-04-27 Sa 23:16]
@@ -2486,40 +2772,44 @@ Yasnippet is a template system. Type an abbreviation, expand it into
 whatever the snippet holds.
 #+BEGIN_SRC emacs-lisp :tangle yes
 (setq yas-snippet-dirs (expand-file-name "yasnippet/snippets" jj-elisp-dir))
-(require 'yasnippet)
-(yas-global-mode 1)
-
-;; Integrate hippie-expand with ya-snippet
-(add-to-list 'hippie-expand-try-functions-list
-             'yas-hippie-try-expand)
-#+END_SRC
-** elpa
-The Emacs Lisp Package Archive (may) contain(s) some things I
-want. Even though I usually only use it to get the package, then when I
-like it move it into my own space. My elpa subdir stays empty.
-#+BEGIN_SRC emacs-lisp :tangle yes
-  (when (> emacs-major-version 23)
-    (require 'package)
-    (setq package-user-dir (expand-file-name "elpa" jj-cache-dir))
-    (package-initialize)
-    (add-to-list 'package-archives '("marmalade" . "http://marmalade-repo.org/packages/"))
-    (add-to-list 'package-archives '("melpa" . "http://melpa.milkbox.net/packages/"))
-    (add-to-list 'package-archives '("elpy" . "http://jorgenschaefer.github.io/packages/"))
-    )
+(use-package yasnippet
+  :ensure yasnippet
+  :init
+  (progn
+    (yas-global-mode 1)
+    ;; Integrate hippie-expand with ya-snippet
+    (add-to-list 'hippie-expand-try-functions-list
+                 'yas-hippie-try-expand)
+    ))
 #+END_SRC
 ** multiple cursors
 [2013-04-08 Mon 23:57]
 Use multiple cursors mode. See [[http://emacsrocks.com/e13.html][Emacs Rocks! multiple cursors]] and
 [[https://github.com/emacsmirror/multiple-cursors][emacsmirror/multiple-cursors · GitHub]]
 #+BEGIN_SRC emacs-lisp :tangle yes
-(safe-load (concat jj-elisp-dir "/multiple-cursors/multiple-cursors-autoloads.el"))
-(define-key region-bindings-mode-map "a" 'mc/mark-all-like-this)
-(define-key region-bindings-mode-map "p" 'mc/mark-previous-like-this)
-(define-key region-bindings-mode-map "n" 'mc/mark-next-like-this)
-(define-key region-bindings-mode-map "l" 'mc/edit-lines)
-(define-key region-bindings-mode-map "m" 'mc/mark-more-like-this-extended)
-(setq mc/list-file (expand-file-name "mc-cache.el" jj-cache-dir))
+(use-package multiple-cursors
+  :ensure multiple-cursors
+  :defer t
+  :bind (("C-S-c C-S-c" . mc/edit-lines)
+         ("C->"     . mc/mark-next-like-this)
+         ("C-<"     . mc/mark-previous-like-this)
+         ("C-c C-<" . mc/mark-all-like-this))
+  :init
+  (progn
+    (bind-key "a" 'mc/mark-all-like-this region-bindings-mode-map)
+    (bind-key  "p" 'mc/mark-previous-like-this region-bindings-mode-map)
+    (bind-key  "n" 'mc/mark-next-like-this region-bindings-mode-map)
+    (bind-key  "l" 'mc/edit-lines region-bindings-mode-map)
+    (bind-key  "m" 'mc/mark-more-like-this-extended region-bindings-mode-map)
+    (setq mc/list-file (expand-file-name "mc-cache.el" jj-cache-dir))))
+#+END_SRC
+** rainbow-mode
+#+BEGIN_SRC emacs-lisp :tangle yes
+(use-package rainbow-mode
+  :ensure rainbow-mode
+  :diminish rainbow-mode)
 #+END_SRC
+
 ** rainbow-delimiters
 [2013-04-09 Di 23:38]
 [[http://www.emacswiki.org/emacs/RainbowDelimiters][EmacsWiki: Rainbow Delimiters]] is a “rainbow parentheses”-like mode
@@ -2528,7 +2818,9 @@ depth. Each successive level is highlighted a different color. This
 makes it easy to spot matching delimiters, orient yourself in the code,
 and tell which statements are at the same depth.
 #+BEGIN_SRC emacs-lisp :tangle yes
-(when (require 'rainbow-delimiters nil 'noerror)
+(use-package rainbow-delimiters
+  :ensure rainbow-delimiters
+  :init
   (global-rainbow-delimiters-mode))
 #+END_SRC
 ** undo-tree
@@ -2539,9 +2831,11 @@ crappy ways one usually knows from other systems which lose
 information. undo-tree is different - it helps keeping you sane while
 keeping the full power of emacs undo/redo.
 #+BEGIN_SRC emacs-lisp :tangle yes
-(require 'undo-tree)
-(global-undo-tree-mode)
-(diminish 'undo-tree-mode)
+(use-package undo-tree
+  :ensure undo-tree
+  :init
+  (global-undo-tree-mode)
+  :diminish undo-tree-mode)
 #+END_SRC
 
 Additionally I would like to keep the region active should I undo
@@ -2564,9 +2858,11 @@ while I have one.
 [2013-04-21 So 20:27]
 Use hyper + arrow keys to switch between visible buffers
 #+BEGIN_SRC emacs-lisp :tangle yes
-(require 'windmove)
-(windmove-default-keybindings 'hyper)
-(setq windmove-wrap-around t)
+(use-package windmove
+  :init
+  (progn
+    (windmove-default-keybindings 'hyper)
+    (setq windmove-wrap-around t)))
 #+END_SRC
 ** volatile highlights
 [2013-04-21 So 20:31]
@@ -2575,32 +2871,108 @@ such as ‘undo’, ‘yank’/’yank-pop’, etc. The highlight disappears at
 next command. The highlighting gives useful visual feedback for what
 your operation actually changed in the buffer.
 #+BEGIN_SRC emacs-lisp :tangle yes
-(require 'volatile-highlights)
-(volatile-highlights-mode t)
-(diminish 'volatile-highlights-mode)
+(use-package volatile-highlights
+  :ensure volatile-highlights
+  :init
+  (volatile-highlights-mode t)
+  :diminish volatile-highlights-mode)
 #+END_SRC
 ** ediff
 [2013-04-21 So 20:36]
 ediff - don't start another frame
 #+BEGIN_SRC elisp
-(require 'ediff)
-(setq ediff-window-setup-function 'ediff-setup-windows-plain)
+(use-package ediff
+  :pre-init
+  (progn
+    (defvar ctl-period-equals-map)
+    (define-prefix-command 'ctl-period-equals-map)
+    (bind-key "C-. =" 'ctl-period-equals-map)
+
+    (bind-key "C-. = c" 'compare-windows)) ; not an ediff command, but it fits
+
+  :bind (("C-. = b" . ediff-buffers)
+         ("C-. = B" . ediff-buffers3)
+         ("C-. = =" . ediff-files)
+         ("C-. = f" . ediff-files)
+         ("C-. = F" . ediff-files3)
+         ("C-. = r" . ediff-revision)
+         ("C-. = p" . ediff-patch-file)
+         ("C-. = P" . ediff-patch-buffer)
+         ("C-. = l" . ediff-regions-linewise)
+         ("C-. = w" . ediff-regions-wordwise)))
 #+END_SRC
 ** re-builder
 Saner regex syntax
 #+BEGIN_SRC emacs-lisp :tangle yes
-(require 're-builder)
-(setq reb-re-syntax 'string)
+(use-package re-builder
+  :command re-builder
+  :defer t
+  :config
+  (setq reb-re-syntax 'string))
 #+END_SRC
 ** magit
 [2013-04-21 So 20:48]
 magit is a mode for interacting with git.
 #+BEGIN_SRC emacs-lisp :tangle yes
-;(require 'magitload)
-(safe-load (concat jj-elisp-dir "/magit/magit-autoloads.el"))
-;(require 'magit-svn)
-(global-set-key (kbd "C-x g") 'magit-status)
-(setq magit-commit-signoff t)
+(use-package magit
+  :ensure magit
+  :commands  (magit-log magit-run-gitk magit-run-git-gui magit-status
+              magit-git-repo-p magit-list-repos)
+  :defer t
+  :bind (("C-x g" . magit-status)
+         ("C-x G" . magit-status-with-prefix))
+  :init
+  (progn
+    (setq magit-commit-signoff t
+          magit-repo-dirs '("~/git"
+                            "/develop/vcs/"
+                            )
+          magit-repo-dirs-depth 4
+          magit-log-auto-more t)
+    (use-package magit-blame
+      :commands magit-blame-mode)
+
+    (use-package magit-filenotify
+      :ensure magit-filenotify)
+
+    (use-package magit-svn
+      :ensure magit-svn
+      :commands (magit-svn-mode
+                 turn-on-magit-svn))
+
+    (add-hook 'magit-mode-hook 'hl-line-mode)
+    (defun magit-status-with-prefix ()
+      (interactive)
+      (let ((current-prefix-arg '(4)))
+        (call-interactively 'magit-status)))
+    )
+  :config
+  (progn
+    (setenv "GIT_PAGER" "")
+
+    (unbind-key "M-h" magit-mode-map)
+    (unbind-key "M-s" magit-mode-map)
+
+    (add-hook 'magit-log-edit-mode-hook
+              #'(lambda ()
+                  (set-fill-column 72)
+                  (flyspell-mode)))
+    ))
+#+END_SRC
+
+** git rebase mode
+#+BEGIN_SRC emacs-lisp :tangle yes
+(use-package git-rebase-mode
+  :ensure git-rebase-mode
+  :commands git-rebase-mode
+  :mode ("git-rebase-todo" . git-rebase-mode))
+#+END_SRC
+** git commit mode
+#+BEGIN_SRC emacs-lisp :tangle yes
+(use-package git-commit-mode
+  :ensure git-commit-mode
+  :commands git-commit-mode
+  :mode ("COMMIT_EDITMSG" . git-commit-mode))
 #+END_SRC
 
 ** lisp editing stuff
@@ -2608,20 +2980,20 @@ magit is a mode for interacting with git.
 I'm not doing much of it, except for my emacs and gnus configs, but
 then I like it nice too...
 #+BEGIN_SRC emacs-lisp :tangle yes
-(define-key read-expression-map (kbd "TAB") 'lisp-complete-symbol)
-(require 'paredit)
+(bind-key "TAB" 'lisp-complete-symbol read-expression-map)
 
-(setq lisp-coding-hook 'lisp-coding-defaults)
-  (setq interactive-lisp-coding-hook 'interactive-lisp-coding-defaults)
+(use-package paredit
+  :ensure paredit
+  :diminish paredit-mode " π")
 
-(after "paredit"
-  '(diminish 'paredit-mode " π"))
+(setq lisp-coding-hook 'lisp-coding-defaults)
+(setq interactive-lisp-coding-hook 'interactive-lisp-coding-defaults)
 
 (setq prelude-emacs-lisp-mode-hook 'prelude-emacs-lisp-mode-defaults)
 (add-hook 'emacs-lisp-mode-hook (lambda ()
                                   (run-hooks 'prelude-emacs-lisp-mode-hook)))
 
-(define-key emacs-lisp-mode-map (kbd "M-.") 'find-function-at-point)
+(bind-key "M-." 'find-function-at-point emacs-lisp-mode-map)
 
 (after "elisp-slime-nav"
   '(diminish 'elisp-slime-nav-mode))
@@ -2636,8 +3008,11 @@ This highlights some /weaselwords/, a mode to /aid in finding common
 writing problems/...
 [2013-04-27 Sa 23:29]
 #+BEGIN_SRC emacs-lisp :tangle yes
-(require 'writegood-mode)
-(global-set-key "\C-cg" 'writegood-mode)
+(use-package writegood-mode
+  :ensure writegood-mode
+  :defer t
+  :init
+  (bind-key "C-c g" 'writegood-mode))
 #+END_SRC
 ** auto-complete mode
 [2013-04-27 Sa 16:33]
@@ -2646,61 +3021,67 @@ much possible work for me as it can.
 So here, auto-complete-mode, which lets emacs do this, based on what I
 already had typed.
 #+BEGIN_SRC emacs-lisp :tangle yes
-(require 'auto-complete)
-(setq ac-comphist-file (expand-file-name "ac-comphist.dat" jj-cache-dir))
-(global-auto-complete-mode t)
-
-(setq ac-expand-on-auto-complete nil)
-(setq ac-dwim t)
-(setq ac-auto-start t)
-
-;;----------------------------------------------------------------------------
-;; Use Emacs' built-in TAB completion hooks to trigger AC (Emacs >= 23.2)
-;;----------------------------------------------------------------------------
-(setq tab-always-indent 'complete)  ;; use 't when auto-complete is disabled
-(add-to-list 'completion-styles 'initials t)
-
-;; hook AC into completion-at-point
-(defun sanityinc/auto-complete-at-point ()
-  (when (and (not (minibufferp)) 
-             (fboundp 'auto-complete-mode)
-             auto-complete-mode)
-    (auto-complete)))
-
-(defun set-auto-complete-as-completion-at-point-function ()
-  (add-to-list 'completion-at-point-functions 'sanityinc/auto-complete-at-point))
-
-(add-hook 'auto-complete-mode-hook 'set-auto-complete-as-completion-at-point-function)
-
-;(require 'ac-dabbrev)
-(set-default 'ac-sources
-             '(ac-source-imenu
-               ac-source-dictionary
-               ac-source-words-in-buffer
-               ac-source-words-in-same-mode-buffers
-               ac-source-words-in-all-buffer))
+(use-package auto-complete
+  :ensure auto-complete
+  :init
+  (progn
+    (global-auto-complete-mode t)
+    )
+  :config
+  (progn
+    (setq ac-comphist-file (expand-file-name "ac-comphist.dat" jj-cache-dir))
+
+    (setq ac-expand-on-auto-complete nil)
+    (setq ac-dwim t)
+    (setq ac-auto-start t)
+
+    ;;----------------------------------------------------------------------------
+    ;; Use Emacs' built-in TAB completion hooks to trigger AC (Emacs >= 23.2)
+    ;;----------------------------------------------------------------------------
+    (setq tab-always-indent 'complete)  ;; use 't when auto-complete is disabled
+    (add-to-list 'completion-styles 'initials t)
+
+    ;; hook AC into completion-at-point
+    (defun sanityinc/auto-complete-at-point ()
+      (when (and (not (minibufferp))
+                 (fboundp 'auto-complete-mode)
+                 auto-complete-mode)
+        (auto-complete)))
+
+    (defun set-auto-complete-as-completion-at-point-function ()
+      (add-to-list 'completion-at-point-functions 'sanityinc/auto-complete-at-point))
+
+    (add-hook 'auto-complete-mode-hook 'set-auto-complete-as-completion-at-point-function)
+
+    ;(require 'ac-dabbrev)
+    (set-default 'ac-sources
+                 '(ac-source-imenu
+                   ac-source-dictionary
+                   ac-source-words-in-buffer
+                   ac-source-words-in-same-mode-buffers
+                   ac-source-words-in-all-buffer))
 ;               ac-source-dabbrev))
 
-(dolist (mode '(magit-log-edit-mode log-edit-mode org-mode text-mode haml-mode
-                sass-mode yaml-mode csv-mode espresso-mode haskell-mode
-                html-mode nxml-mode sh-mode smarty-mode clojure-mode
-                lisp-mode textile-mode markdown-mode tuareg-mode python-mode
-                js3-mode css-mode less-css-mode sql-mode ielm-mode))
-  (add-to-list 'ac-modes mode))
+    (dolist (mode '(magit-log-edit-mode log-edit-mode org-mode text-mode haml-mode
+                                        sass-mode yaml-mode csv-mode espresso-mode haskell-mode
+                                        html-mode nxml-mode sh-mode smarty-mode clojure-mode
+                                        lisp-mode textile-mode markdown-mode tuareg-mode python-mode
+                                        js3-mode css-mode less-css-mode sql-mode ielm-mode))
+      (add-to-list 'ac-modes mode))
 
 ;; Exclude very large buffers from dabbrev
-(defun sanityinc/dabbrev-friend-buffer (other-buffer)
-  (< (buffer-size other-buffer) (* 1 1024 1024)))
+    (defun sanityinc/dabbrev-friend-buffer (other-buffer)
+      (< (buffer-size other-buffer) (* 1 1024 1024)))
 
-(setq dabbrev-friend-buffer-function 'sanityinc/dabbrev-friend-buffer)
+    (setq dabbrev-friend-buffer-function 'sanityinc/dabbrev-friend-buffer)
 
 
 ;; custom keybindings to use tab, enter and up and down arrows
-(define-key ac-complete-mode-map "\t" 'ac-expand)
-(define-key ac-complete-mode-map "\r" 'ac-complete)
-(define-key ac-complete-mode-map "\M-n" 'ac-next)
-(define-key ac-complete-mode-map "\M-p" 'ac-previous)
-(define-key ac-mode-map (kbd "M-TAB") 'auto-complete)
+(bind-key "\t" 'ac-expand ac-complete-mode-map)
+(bind-key "\r" 'ac-complete ac-complete-mode-map)
+(bind-key "M-n" 'ac-next ac-complete-mode-map)
+(bind-key "M-p" 'ac-previous ac-complete-mode-map)
+(bind-key "M-TAB" 'auto-complete ac-mode-map)
 
 (setq auto-completion-syntax-alist (quote (global accept . word))) ;; Use space and punctuation to accept the current the most likely completion.
 (setq auto-completion-min-chars (quote (global . 3))) ;; Avoid completion for short trivial words.
@@ -2709,19 +3090,20 @@ already had typed.
 (add-hook 'latex-mode-hook 'auto-complete-mode)
 (add-hook 'LaTeX-mode-hook 'auto-complete-mode)
 (add-hook 'prog-mode-hook 'auto-complete-mode)
-(add-hook 'org-mode-hook 'auto-complete-mode)
+(add-hook 'org-mode-hook 'auto-complete-mode)))
 #+END_SRC
+
 ** yaml-mode
 [2013-04-28 So 01:13]
 YAML is a nice format for data, which is both, human and machine
 readable/editable without getting a big headache.
 #+BEGIN_SRC emacs-lisp :tangle yes
-(require 'yaml-mode)
-(add-auto-mode 'yaml-mode "\\.yml$")
-(add-auto-mode 'yaml-mode "\\.yaml$")
-(add-hook 'yaml-mode-hook
- '(lambda ()
-    (define-key yaml-mode-map "\C-m" 'newline-and-indent)))
+(use-package yaml-mode
+  :ensure yaml-mode
+
+  :mode ("\\.ya?ml\\'" . yaml-mode)
+  :config
+    (bind-key "C-m" 'newline-and-indent yaml-mode-map ))
 #+END_SRC
 
 ** flycheck
@@ -2730,15 +3112,18 @@ Flycheck is a on-the-fly syntax checking tool, supposedly better than Flymake.
 As the one time I tried Flymake i wasn't happy, thats easy to
 understand for me.
 #+BEGIN_SRC emacs-lisp :tangle yes
-(when (> emacs-major-version 23)
-  (require 'flycheck)
+(use-package flycheck
+  :ensure flycheck
+  :init
   (add-hook 'after-init-hook #'global-flycheck-mode))
 #+END_SRC
 ** crontab-mode
 [2013-05-21 Tue 23:18]
 #+BEGIN_SRC emacs-lisp :tangle yes
-(require 'crontab-mode)
-(add-auto-mode 'crontab-mode "\\.?cron\\(tab\\)?\\'")
+(use-package crontab-mode
+  :ensure crontab-mode
+  :commands crontab-mode
+  :mode ("\\.?cron\\(tab\\)?\\'" . crontab-mode))
 #+END_SRC
 
 ** nxml
@@ -2795,22 +3180,58 @@ Programming in ruby...
 
 *** Config
 #+BEGIN_SRC emacs-lisp :tangle yes
-(after 'ruby-mode
-       (message "ruby has been loaded")
-       (define-key ruby-mode-map (kbd "RET") 'reindent-then-newline-and-indent)
-       (define-key ruby-mode-map (kbd "TAB") 'indent-for-tab-command)
-
-       (require 'ruby-hash-syntax)
-       (require 'inf-ruby)
-       (setq ruby-use-encoding-map nil)
-       ;; Stupidly the non-bundled ruby-mode isn't a derived mode of
-       ;; prog-mode: we run the latter's hooks anyway in that case.
-       (add-hook 'ruby-mode-hook
-                 (lambda ()
-                   (unless (derived-mode-p 'prog-mode)
-                     (run-hooks 'prog-mode-hook))))
-
-       )
+(use-package ruby-mode
+  :mode ("\\.rb\\'" . ruby-mode)
+  :interpreter ("ruby" . ruby-mode)
+  :defer t
+  :config
+  (progn
+    (use-package yari
+      :init
+      (progn
+        (defvar yari-helm-source-ri-pages
+          '((name . "RI documentation")
+            (candidates . (lambda () (yari-ruby-obarray)))
+            (action  ("Show with Yari" . yari))
+            (candidate-number-limit . 300)
+            (requires-pattern . 2)
+            "Source for completing RI documentation."))
+
+        (defun helm-yari (&optional rehash)
+          (interactive (list current-prefix-arg))
+          (when current-prefix-arg (yari-ruby-obarray rehash))
+          (helm 'yari-helm-source-ri-pages (yari-symbol-at-point)))))
+
+    (defun my-ruby-smart-return ()
+      (interactive)
+      (when (memq (char-after) '(?\| ?\" ?\'))
+        (forward-char))
+      (call-interactively 'newline-and-indent))
+
+    (use-package ruby-hash-syntax
+      :ensure ruby-hash-syntax)
+
+    (defun my-ruby-mode-hook ()
+      (require 'inf-ruby)
+      (inf-ruby-keys)
+
+      (bind-key "<return>" 'my-ruby-smart-return ruby-mode-map)
+      ;(bind-key "<tab>" 'indent-for-tab-command ruby-mode-map)
+
+       
+      (set (make-local-variable 'yas-fallback-behavior)
+           '(apply ruby-indent-command . nil))
+      (bind-key "<tab>" 'yas-expand-from-trigger-key ruby-mode-map))
+
+    (add-hook 'ruby-mode-hook 'my-ruby-mode-hook)
+
+    ;; Stupidly the non-bundled ruby-mode isn't a derived mode of
+    ;; prog-mode: we run the latter's hooks anyway in that case.
+    (add-hook 'ruby-mode-hook
+              (lambda ()
+                (unless (derived-mode-p 'prog-mode)
+                  (run-hooks 'prog-mode-hook))))
+  ))
 #+END_SRC
 ** emms
 EMMS is the Emacs Multimedia System.
@@ -2976,9 +3397,9 @@ Yet another folding extension for the Emacs editor. Unlike many
 others, this one works by just using the existing indentation of the
 file, so basically works in every halfway structured file.
 #+BEGIN_SRC emacs-lisp :tangle yes
-(define-key global-map (kbd "C-#") 'yafolding)
+(bind-key "C-#" 'yafolding)
 ;;(define-key global-map (kbd "C-c C-f") 'yafolding-toggle-all)
-(define-key global-map (kbd "C-c C-f") 'yafolding-toggle-all-by-current-level)
+(bind-key "C-c C-f" 'yafolding-toggle-all-by-current-level)
 #+END_SRC
 ** icomplete
 Incremental mini-buffer completion preview: Type in the minibuffer,