Ask HN Emacs Users: What's in your .emacs file?

Some noteworthy things:

It's a ~1200 line file (and expanding) this is how I navigate it:

    (defun show-dot-emacs-structure ()
      "Show the outline-mode structure of ~/.emacs"
      (interactive)
      (occur "^;;;;+"))

    74 matches for "^;;;;+" in buffer: .emacs
     57:;;;; Debugging
     67:;;;; Load paths
    112:;;;; Emacs' interface
    229:;;;; User info
    236:;;;; Encoding
    253:;;;; Indenting
    273:;;;;; Per-project indentation settings
    275:;;;;;; Git

    ;; Don't display the 'Welcome to GNU Emacs' buffer on startup
    (setq inhibit-startup-message t)
    
    ;; Display this instead of "For information about GNU Emacs and the
    ;; GNU system, type C-h C-a.". This has been made intentionally hard
    ;; to customize in GNU Emacs so I have to resort to hackery.
    (defun display-startup-echo-area-message ()
      "If it wasn't for this you'd be GNU/Spammed by now"
      (message ""))
    
    ;; Don't insert instructions in the *scratch* buffer
    (setq initial-scratch-message nil)

    ;; Display the line and column number in the modeline
    (setq line-number-mode t)
    (setq column-number-mode t)
    (line-number-mode t)
    (column-number-mode t)
    
    ;; syntax highlight everywhere
    (global-font-lock-mode t)
    
    ;; Show matching parens (mixed style)
    (show-paren-mode t)
    (setq show-paren-delay 0.0)
    
    ;; 'mixed highligts the whole sexp making it unreadable, maybe tweak
    ;; color display?
    (setq show-paren-style 'parenthesis)
    
    ;; Highlight selection
    (transient-mark-mode t)
    
    ;; make all "yes or no" prompts show "y or n" instead
    (fset 'yes-or-no-p 'y-or-n-p)

    ;; Switching
    (iswitchb-mode 1)
    (icomplete-mode 1)

    ;; I use version control, don't annoy me with backup files everywhere
    (setq make-backup-files nil)
    (setq auto-save-default nil)

    ;;; Electric minibuffer!
    ;;; When selecting a file to visit, // will mean / and
    ;;; ~ will mean $HOME regardless of preceding text.
    (setq file-name-shadow-tty-properties '(invisible t))
    (file-name-shadow-mode 1)

    (defun backward-delete-whitespace-to-column ()
      "delete back to the previous column of whitespace, or just one
    char if that's not possible. This emulates vim's softtabs
    feature."
      (interactive)
      (if indent-tabs-mode
          (call-interactively 'backward-delete-char-untabify)
        ;; let's get to work
        (let ((movement (% (current-column) tab-width))
              (p (point)))
          ;; brain freeze, should be easier to calculate goal
          (when (= movement 0) (setq movement tab-width))
          (if (save-excursion
                (backward-char movement)
                (string-match "^\\s-+$" (buffer-substring-no-properties (point) p)))
              (delete-region (- p movement) p)
            (call-interactively 'backward-delete-char-untabify)))))
    
    (global-set-key (kbd "<DEL>") 'backward-delete-whitespace-to-column)

For libraries I use (eval-after-load) for everything and (autoload). It really speeds up startup.

ack is a much better M-x grep (needs ack.el):

    ;;;;; ack
    (defalias 'grep 'ack)

    (defun run-clojure ()
      "Starts clojure in Slime"
      (interactive)
      (pre-slime)
      (slime 'clojure))
    
    (defun run-sbcl ()
      "Starts SBCL in Slime"
      (interactive)
      (pre-slime)
      (slime 'sbcl))

    ;;;;; nopaste.el
    (autoload 'nopaste "nopaste" nil t)
    
    (eval-after-load "nopaste"
      '(progn
         (setq nopaste-nickname "avar")
         (setq nopaste-channel  nil)
         (setq nopaste-description nil)))
    
    (global-set-key (kbd "C-c n p") 'nopaste)
    (global-set-key (kbd "C-c n y") 'nopaste-yank-url)

    ;;;;; Emacs Chrome edit server - http://wiki.github.com/stsquad/emacs_chrome/
    (when (getenv "DISPLAY")
      (require 'edit-server)
      (setq edit-server-new-frame nil)
      (add-hook 'edit-server-done-hook 'on-edit-server-done-do-backup)
      (edit-server-start))

    (defun on-edit-server-done-do-backup ()
      "Run when text is sent to Google Chrome. Do a backup of the
    stuff sent there in case something goes wrong, e.g. Chrome
    crashes."
      (let* ((backup-dir "~/._emacs_chrome-backup")
            (backup-file (format "%s.txt" (float-time)))
            (backup-path (concat backup-dir "/" backup-file)))
        (unless (file-directory-p backup-dir)
          (make-directory backup-dir))
        (write-region (point-min) (point-max) backup-path)))
    

    (global-set-key (kbd "C-c k") 'browse-kill-ring)

  (setq viper-mode t)
  (require 'viper)

  (custom-set-variables
   '(column-number-mode t)
   '(inhibit-startup-screen t)
   '(show-paren-mode t)
   '(tool-bar-mode nil)
   '(menu-bar-mode nil))

http://github.com/daemianmack/emacs-starter-kit/

Favorite two most recent additions: pyflakes/pylint for Python, and rainbow-mode for CSS.

[1] Having backward-kill-word a two-finger-stroke, instead of the two-handed alt+Backspace, is great! On the other hand, it turns out I kill-region a lot more than I thought I did, so that's a little weird.

    (setq-default show-trailing-whitespace t)
    (setq longlines-show-hard-newlines t) ; displays "\" at the end of lines that wrap past the window's edge

    ; camel case word navigation
    (when (boundp 'subword-mode)
      (add-hook 'after-change-major-mode-hook '(lambda () (subword-mode 1))))

    ; Bindings
    (defun delete-backward-indent (&optional arg)
      "Erase a level of indentation, or 1 character"
      (interactive "*P")
      (if (= (current-column) 0)
          (delete-backward-char 1)
        (let ((n (mod (current-column) standard-indent)))
          (if (looking-back (concat "^\s*" (make-string n 32)))
              (if (= n 0)
                  (delete-backward-char standard-indent)
                (delete-backward-char n))
            (delete-backward-char 1)))))

    (defun newline-maybe-indent ()
      "Like newline-and-indent, but doesn't indent if the previous line is blank"
      (interactive "*")
      (if (= (line-beginning-position) (line-end-position))
          (newline)
        (newline-and-indent)))

    (add-hook 'python-mode-hook
              '(lambda ()
                 (hs-minor-mode 1) ; code folding
                 (define-key python-mode-map (kbd "RET") 'newline-maybe-indent)
                 (define-key python-mode-map (kbd "DEL") 'delete-backward-indent)
                 (define-key python-mode-map (kbd "M-RET") 'hs-toggle-hiding)))

    ; On-the-fly spell checking
    (add-hook 'python-mode-hook '(lambda () (flyspell-prog-mode)))

    ; On-the-fly pyflakes checking
    (require 'flymake-point) ; shows errors in the minibuffer when highlighted (http://bitbucket.org/[redacted]/dotfiles/src/tip/.emacs.d/plugins/flymake-point.el)
    (setq python-check-command "pyflakes")
    (when (load "flymake" t)
      (defun flymake-pyflakes-init ()
        (let* ((temp-file (flymake-init-create-temp-buffer-copy
                           'flymake-create-temp-inplace))
               (local-file (file-relative-name
                            temp-file
                            (file-name-directory buffer-file-name))))
          (list "pyflakes" (list local-file))))
      (add-to-list 'flymake-allowed-file-name-masks
                   '("\\.py\\'" flymake-pyflakes-init)))
    (add-hook 'python-mode-hook '(lambda () (flymake-mode 1)))

My entire .emacs is here: http://bitbucket.org/[redacted]/dotfiles/src/tip/.emacs

The boring stuff is all in the Starter Kit: http://github.com/technomancy/emacs-starter-kit

  ;; fonts
  (if (eq window-system 'x)
      (set-default-font "Inconsolata-12"))

  ;; no tabs, spaces instead!
  (setq-default indent-tabs-mode nil)

  ;; Changes all yes/no questions to y/n type
  (fset 'yes-or-no-p 'y-or-n-p)

  ;; default modes
  (iswitchb-mode t)
  (icomplete-mo)
  (column-number-mode)
  (ido-mode)
  (tabbar-mode)
  (winner-mode)

  ;; ido-mode

  ;; do not confirm file creation
  (setq confirm-nonexistent-file-or-buffer nil)

  ;; integrate copy/paste with X
  (setq x-select-enable-clipboard t)
  (setq interprogram-paste-function 'x-cut-buffer-or-selection-value)

  ;; scroll
  (setq scroll-step 1)

  ;; save backup files in this directory
  (setq backup-directory-alist (quote ((".*" . "~/.emacs.d/backups/"))))

  ;; global bindings
  (global-set-key [C-tab] 'other-window)
  (global-set-key "\r" 'newline-and-indent)
  (global-set-key (kbd "C-;") 'comment-region)
  (global-set-key (kbd "<f8>") '(lambda ()
                                (interactive)
                                (split-window-vertically 25)
                                (other-window 1)
                                (slime)))

  ; switch buffer with last previous buffer
  (global-set-key (kbd "<C-return>") '(lambda ()
                                      (interactive)
                                      (switch-to-buffer nil)))
  (global-set-key (kbd "C-p") 'backward-char)
  (global-set-key (kbd "C-S-p") 'previous-line)
  (global-set-key (kbd "C-S-j") 'join-line)
  (global-set-key (kbd "C-<prior>") 'tabbar-forward)
  (global-set-key (kbd "C-<next>") 'tabbar-backward)

  ;; fullscreen on F11
  (defun toggle-fullscreen (&optional f)
    (interactive)
    (let ((current-value (frame-parameter nil 'fullscreen)))
      (set-frame-parameter nil 'fullscreen
                         (if (equal 'fullboth current-value)
                             (if (boundp 'old-fullscreen) old-fullscreen nil)
                           (progn (setq old-fullscreen current-value)
                                  'fullboth)))))

  (global-set-key [f11] 'toggle-fullscreen)

Specifically, my favorite things are show-paren-mode, ido-mode, and rebinding C-, and C-. to move back and forward between windows.

It's quite large, and includes a lot of third-party stuff, much of it as submodules.

It's relocatable (with additional platform and/or machine-specific loads) which might be semi-interesting: http://everythingtastesbetterwithchilli.com/initialisation-f...

Little things off the top of my head that I find useful: * wind-move -- use shift-arrow keys for window navigation * (fset 'yes-or-no-p 'y-or-n-p) * browse-kill-ring * mic-paren-mode * rename-file-and-buffer from Yegge * unscroll (undo inadvertent C-v) from Glickstein's book * lots of little tweaks like using C-,/. for smooth scrolling up/down * uniquify to keep buffer names unique * find-file-at-point

Lots of autloads for more efficient initialisation (although that's less of an issue now that I'm using --daemon at startup)

I do the usual UI tweaks like turning off the menu and tool bar, using ido mode (with smex -- ido for commands), etc. There's not a lot of keys that I rebind, but I do change backward-kill-word to C-w (consistent with shell usage), and kill-region to C-xC-k. Both those suggestions were from Yegge's effective emacs article which is worth a browse; I've ignored his advice to also change M-x to C-xC-m though.

I've modified it slightly, but overall it set emacs up better than I new was possible (and introduced me to some add ons I didn't know existed).

    ; Fix copy-paste between emacs and other x programs
    (setq x-select-enable-clipboard t)
    (if (functionp 'x-cut-buffer-or-selection-value)
        (setq interprogram-paste-function 'x-cut-buffer-or-selection-value))

The if statement stops it failing when you use it on other platforms.

EDIT: I also really really like this bit which I've not seen in other peoples lists:

    (defun eshell-goto-current-dir (&optional arg)
      (interactive "P")
      (let ((dir default-directory))
        (eshell arg)
        (eshell/cd dir)))

    (global-set-key "\C-cs" 'eshell)
    (global-set-key "\C-cS" 'eshell-goto-current-dir)

  ;; Makes editing without Paredit more convenient... 
  ;; But if you're on linux, first prevent it from logging you out!
  (global-set-key [C-M-delete] 'backward-kill-sexp)
  (global-set-key [C-M-backspace] 'backward-kill-sexp)

  ;; Command key meta forever.
  (labels ((normal-mac-mods (&rest _) (setq ns-alternate-modifier 'none
                                            ns-command-modifier 'meta)))
    (add-hook 'after-make-frame-functions #'normal-mac-mods)
    (normal-mac-mods))

  (setq-default ...

                ;; Make the default buffer a little shinier... also, put
                ;;   (message "Ready")
                ;; at the end of the file

                initial-major-mode 'text-mode
                initial-scratch-message (concat "                  ···"
                                                "--—=====   Welcome to Emacs"
                                                "   =====—--···\n===---···"
                                                "                 "
                                                "···---================---···"
                                                "                ···---===\n\n")

    (global-set-key (kbd "C-=") 'switch-to-previous-buffer)
    (defun switch-to-previous-buffer ()
      (interactive)
      (switch-to-buffer (other-buffer)))

    (global-set-key (kbd "C-z") 'shell)

    (defun my-shell-mode-hook ()
      (local-set-key (kbd "C-z") 'bury-buffer))
    (add-hook 'shell-mode-hook 'my-shell-mode-hook)

    ;; recent files
    (require 'recentf)
    (recentf-mode 1)
    (setq recentf-max-menu-items 25)
    (global-set-key "\C-x\ \C-r" 'recentf-open-files)

* Undo-tree. (http://www.emacswiki.org/emacs/UndoTree) Makes emacs undo useful.

This has been one of the most useful functions I've added to my .emacs:

   (defun xsteve-ido-choose-from-recentf ()
     "Use ido to select a recently opened file from the `recentf-list'"
     (interactive)
     (let ((home (expand-file-name (getenv "HOME"))))
       (find-file
        (ido-completing-read "Recentf open: "
                             (mapcar (lambda (path)
                                       (replace-regexp-in-string home "~" path))
                                     recentf-list)
                             nil t))))

   (global-set-key [(meta f11)] 'xsteve-ido-choose-from-recentf)

gist.el, powershell-mode, yaml-mode, org-mode are a few I've taken out for brevity.

Otherwise, a few of these are emacs23 specific:

  ;; syntax highlighting
  (global-font-lock-mode 1)
  
  ;; add .emacs.d to load path
  (setq load-path (cons "~/.emacs.d" load-path))
  
  ;; nethack
  (add-hook 'nethack-mode-hook (lambda () (linum-mode 'nil)))
  (setq load-path (cons "~/.emacs.d/nethack" load-path))
  (autoload 'nethack "nethack" "Play Nethack." t)
  (setq nethack-program "/opt/local/bin/nethack")
  
  ;; 4 spaces in objective-c
  (add-hook 'objc-mode-hook
            (lambda ()
              (setq tab-width nil)
              (setq c-basic-offset 4)))
  
  ;; straight to *scratch* buffer please
  (setq inhibit-splash-screen t)
  
  ;; use old navigation for line movement
  (setq line-move-visual nil)

  ;; linum mode
  (require 'linum)
  (global-linum-mode 1)
  (add-hook 'linum-before-numbering-hook
  	  (lambda () (setq linum-format "%d ")))

startup.el is the main starting point (I load that from my .emacs). Can't say it's the cleanest set of config files, but you might find something of use in it.

Some of the things I've configured:

- Detect whether Emacs is running in OS X, Linux, Windows (native), or Cygwin; and I do platform-specific configuration when necessary

- For OS X, I use fixpath.el to load my path by executing bash (I've tried various methods of doing this, and this was the most reliable)

- For Windows, I have Powershell configured

- I'm using guess-style ( http://nschum.de/src/emacs/guess-style/ ): auto-detects indentation style.

- I had a Clojure setup that was working nicely, but it's been a while since I used it and I need to update it for Clojure 1.2

- ido-mode is great. I have some specific settings for that. For example, enabling ido-enable-flex-matching makes it easier to quickly match files

- Backups go to ~/.emacs.d/backup instead of littering ~ files everywhere. The backup folder is created if necessary.

- YASnippets. I've created some snippets of my own, such as for wikipedia-mode

- I had problems using markdown-mode with YASnippets (both want to use the tab key), but was able to fix this. See my "eval-after-load 'markdown-mode" for this.

If you use YASnippet, I've taken Jeff Wheeler's Textmate-to-YASnippet conversion script and improved it here: http://github.com/nileshk/snippet-copier That also contains a Eclipse template to YASnippet convertor script I started on which kinda works, though not perfectly.

Pressing Return starts a new line at column 0, pressing Control j starts a new indented line. I prefer them the other way round, so I rebind:

    (global-set-key "\r" 'newline-and-indent)
    (global-set-key "\C-j" 'newline)

    (defun next-newline-and-indent ()
      (interactive)
      (end-of-line)
      (newline-and-indent))
    (global-set-key [C-return] 'next-newline-and-indent)

    (defun prev-newline-and-indent ()
      (interactive)
      (beginning-of-line)
      (open-line 1)
      (indent-according-to-mode))
    (global-set-key [C-S-return] 'prev-newline-and-indent)

I don't like tabs!

  ;; destroy all tabs
  (setq-default indent-tabs-mode nil)
  (defun untab-writable-non-makefiles-and-csv ()
   (if (and
        (not buffer-read-only)
        (not (loop for re in '("[Mm]akefile" "\\.mk" "\\.csv" "\\.txt")
                   if (string-match re buffer-file-name)
                   do (return t)
                   finally (return nil))))
       (untabify (point-min) (point-max))))
  (add-hook 'find-file-hook 'untab-writable-non-makefiles-and-csv)

  ;; use this to start server for emacsclient
  (if (not (boundp 'server-process))
     (server-start))

  ;; tramp mode...
  (setq load-path (cons "~/emacs/tramp" load-path))
  (require 'tramp)
  (setq tramp-default-method "ssh")

  ;; remote shell! Hooray!
  (require 'ssh)
  (add-hook 'ssh-mode-hook 'ssh-directory-tracking-mode)

  ;; back to emacswiki.org/emacs/DeskTop
  (setq *foo-desktop-dir* (expand-file-name "~/emacs/desktop"))
  (setq desktop-dir *foo-desktop-dir*)
  (setq desktop-path (list *foo-desktop-dir*))
  (desktop-save-mode 1) ;; Switch on desktop.el
  (setq *foo-desktop-file* (concatenate 'string desktop-dir
                                       "/" desktop-base-file-name))
  (setq *foo-desktop-lock* (concatenate 'string desktop-dir
                                       "/" desktop-base-lock-name))
  (defun desktop-in-use-p ()
   (and (file-exists-p *foo-desktop-file*) (file-exists-p *foo-desktop-lock*)))
  (defun autosave-desktop ()
   (if (desktop-in-use-p) (desktop-save-in-desktop-dir)))
  (add-hook 'auto-save-hook 'autosave-desktop)

To mimic some of TextMate's functionality, I use:

1. autopair.el: http://www.emacswiki.org/emacs/AutoPairs.

2. yasnippet.el: http://code.google.com/p/yasnippet/

The latest version of Emacs for the MacOSX has an awesome fullscreen capability. I followed the instructions here: http://www.sanityinc.com/full-screen-support-for-cocoa-emacs...

iswitchb-mode has awesome minibuffer completion capabilities. http://www.emacswiki.org/emacs/IswitchBuffers

    ; I type this by mistake 80% of the time
    (global-unset-key (kbd "C-x C-c"))

    ; One of my favorite commands
    (global-set-key "\C-x\C-j" 'join-line)

    ; I haven't seen a keyboard with "copy" and "paste" buttons since 2008
    ; Honestly, Emacs' defaults, WTF
    (global-set-key (kbd "<f2>") 'clipboard-kill-ring-save)
    (global-set-key (kbd "<f3>") 'clipboard-yank)

plus

http://lisp.pastebin.com/raw.php?i=MRbccMG4

http://github.com/Nafai77/config/tree/master/HOME/_emacs.d/

One of the next things I'm going to do is explore using el-get. It's always a pain moving to a new machine and having to download and checkout all of the third-party libraries I use.

  (server-start)

  ;; no Tabs
  (setq-default indent-tabs-mode nil)
  (setq-default tabs-width 2)

  ;; List more buffers in the buffer menu
  (setq-default buffers-menu-max-size 30)

  ;; Prevent startup message and switch to empty *scratch*
  (setq inhibit-startup-message t)
  (setq initial-scratch-message nil)

  ;; Fix C&P
  (setq x-select-enable-clipboard t)

  ;; Make Caps Lock LED blink instead of audio bell
  (setq visible-bell 1)
  (setq ring-bell-function
        (lambda ()
          (when (getenv "DISPLAY")
            (call-process-shell-command "xset led named \"Scoll Lock\"; xset -led named \"Scroll Lock\"" nil 0 nil))))

  (show-paren-mode 1)
  (column-number-mode 1)

  ;; Keep the custom stuff separate
  (setq custom-file "~/.emacs.d/custom.el")
  (load custom-file)

  ;; I know what downcase-region does. Me no noob anymore ;). So undisable it.
  (put 'downcase-region 'disabled nil)

  ;; This can be a life saver!
  (push '("." . "~/.emacs.d/backups") backup-directory-alist)

  ;; Create better buffer names. foo.c++:src, foo.c++:extra instead of foo.c++ and foo.c++<2>
  ;; This should really be the default behaviour for Emacs!
  (require 'uniquify)
  (setq 
    uniquify-buffer-name-style 'reverse
    uniquify-separator ":")

  ;; c-mode hook to set better default compile-command if no Makefile exists and activate flyspell-prog-mode
  ;; I have similar hooks for c-mode and fortran-mode
  (add-hook 'c++-mode-hook
          (lambda ()
            (flyspell-prog-mode)
            (unless (or (file-exists-p "Makefile")
                        (local-variable-p 'compile-command)
                        (not buffer-file-name))
              (set (make-local-variable 'compile-command)
                   (format "%s %s %s"
                           (or (getenv "CXX") "g++")
                           (or (getenv "CXXFLAGS")
                               "-pipe -std=c++0x -pedantic-errors -Wall -Wextra -Weffc++ -g3")
                           (file-name-nondirectory buffer-file-name))))))

  ;; Set f9 to compiler and f8 to make clean
  (global-set-key '[f9] 'compile)
  (global-set-key '[f8] '(lambda ()
                          (interactive)
                          (when (file-exists-p "Makefile") (compile "make clean"))))

This is super useful to me:

    (global-set-key [f6] 'linum-mode)
    (global-set-key [f7] 'next-buffer)
    (global-set-key [f8] 'previous-buffer)

And most importantly, I setup my font to monaco, tango color scheme and I prefer full screen emacs, so i have a bit of an involved process where I have basically this:

    (global-set-key [f11] 'ds-darkroom)
    (global-set-key [f12] 'menu-bar-mode)

clean darkroom - http://i.imgur.com/LloOY.png

with menu - http://i.imgur.com/yTeUz.png

I'm trying for years to force myself not to move my right hand to arrows and instead use C-p C-n and C-b C-f, but I can't (well sometimes I do, but not all the time).

And various tweaks here and there, I might have forgotten something though.

If you use Viper, this is the single nicest tip I have: http://edward.oconnor.cx/2009/08/viper-tweaks

Some tips on running a dedicated Emacs instance for Gnus: http://edward.oconnor.cx/2010/08/standalone-gnus

Some notable items:

    ;;; allow seperating out the config stuff to 
    ;;; into different files
    (defvar jaw:config-dir (expand-file-name "~/.emacs.d/conf.d")
      "My config parts directory location.")

    (defun jaw:load-confs ()
     "Load Jeremy's config file parts"
     (let ((files (sort (directory-files jaw:config-dir) 'string<)))
       (while files
         (setq file (car files)
               files (cdr files))
         (cond ((string-match ".*\.#[^/]+\.el$" file)
                nil)
               ((string-match ".*\.elc?$" file)
                (load-file (concat jaw:config-dir "/" file)))))))

    (jaw:load-confs)

My favorite new thing is my thumb-through: http://github.com/apgwoz/thumb-through, which allows me to easily read articles from irc (i use rcirc) without leaving emacs, or loading up w3m-mode.

  ;; don't sleep emacs accidentally
  (global-set-key [(control z)] nil)
  
  ;; shortcut buffer navigation
  (global-set-key [f5] 'previous-buffer)
  (global-set-key [f8] 'next-buffer)
  
  ;; show columns by default
  (column-number-mode)
  
  ;; stop the blinking
  (blink-cursor-mode nil)

Linky: http://github.com/troelskn/troelskn-emacs

- IDO

- Smex

- (Enhanced) project-root.el ( http://piranha.org.ua/project-root/ ) and its project-root-find-file function.

(and my modular configuration is here: http://github.com/lvillani/.emacs.d)

(setq slime-lisp-implementations '((ccl ("/usr/local/ccl/dx86cl64")) (sbcl ("/usr/local/bin/sbcl")))) (add-to-list 'load-path "/usr/local/slime/") (require 'slime) (slime-setup '(slime-repl slime-banner))

My entire .emacs file:

(defun sbcl ()

  (show-paren-mode)

  (setq inferior-lisp-program "sbcl")

  (add-to-list 'load-path "~/emacs/slime")

  (require 'slime)

  (slime-setup))

(defun force-revert-buffer () (interactive) (revert-buffer t t))

(define-key global-map "\C-cr" 'force-revert-buffer)

It uses org-babel to keep it organized and readable so really there's a short wrapper init.el that then calls babel-init.org

External packages are installed system-wide using my own .SlackBuild generated packages (@ http://github.com/cycojesus/slackbuilds/tree/master/e/ )

Of course I run Slackware.

textmate.el is pretty awesome, as is ide-skel.

  (setq Buffer-menu-use-frame-buffer-list nil)

  ;; move along, nothing to see here :P
  ;; the beef is in ~/.vimrc and under ~/.vim/ ;)