The basic init.el file loads my various language modes, and some other minor modes (e.g., tempbuf-mode). It also loads a bunch of files from the "emacs.d/my_lisp" directory which contains various overrides and new functionality attached to existing modes (e.g., icicles customization, assorted one-off functions I want to add to modes). Lastly, it loads a bunch more files from my emacs.d/lisp directory which implement custom functionality.

For example, the current emacs M-x eshell doesn't behave the way I like. I often want multiple shells, so I've build a "ring of shells" functionality: f6 cycles through the ring of shells, C-f6 creates new shell window in the ring. I did something similar with window configurations.

Also, the emacs.d stores all modes which I use regularly. So when I migrate to a new computer, all I need to do is

    darcs get me@oldbox:emacs.d

Lots of cruft (roughly 10 years worth), although I did recently start to refactor.

Most notable: it's fairly portable and relocatable, thanks to a snippet I cooked up (probably not original, but I haven't seen it else-where): http://everythingtastesbetterwithchilli.com/initialisation-f... (check it out anywhere and just symlink init.el to ~/.emacs, it figures out all paths from there. It'll also load platform-specific code, if you need that).

I try and make it lazier by combining autoload and eval-after-load, which helps with startup time.

On an organisational point (still work to be done here!), init.el mostly just loads a bunch of other files, which are roughly grouped by task or mode. Github has been a huge boon, combined with submodules to track a lot of third-party extensions.

I don't change many key bindings (most notable is the Yegge-suggested C-w for backward-kill-word), but I do have a /lot/ of extensions installed. I'm a fairly heavy user, although almost exclusively as an editor (+ lisp or python interaction, etc) -- I don't use it as a mail client, browser, or anything along those lines. The furthest away I get is the occasional twitter or IRC usage.

While I'm rambling: I'd like to make all my key-binding specifications consistent. Currently I have a mix of string specifications, vectors, kbd macros, etc. Does anyone know what the canonical approach is these days? Extra reference: http://www.nongnu.org/emacs-tiny-tools/keybindings/ and http://www.emacswiki.org/emacs/KeyBindingNotation

For uninitiated, C-w is "yank text", i.e. cut it, and Firefox it is "close current tab without warning".

https://addons.mozilla.org/en-US/firefox/addon/4141

Still, your lapse is pretty good. Sometimes I can't even name the keys -- but my fingers know :)

Clone that as your emacs.d, add a .el file named the same as your logged in user, and add your specific preferences there. (I like to have it include stuff in a jmhodges directory in emacs.d, of course.)

On that note, my own fork of it with very minor personal changes: https://github.com/jmhodges/emacs-starter-kit

  ;; how emacs behaves generally
  (setq scroll-step 1)
  (setq next-line-add-newlines nil)
  (setq search-highlight t)
  (setq-default indent-tabs-mode nil)

  ;; some niceties on the status bar
  (display-time)
  (setq column-number-mode t)
  (setq line-number-mode t)

  ;; other shortcuts
  (global-set-key "\C-^" 'enlarge-window)
  (global-set-key "\C-c\C-w" 'compare-windows)

  ;; fix broken backspace
  (global-set-key "\b" 'backward-delete-char)
  (global-set-key "\C-xt" 'term)

  ;; UTF-8 goodness
  (set-terminal-coding-system 'utf-8)
  (set-keyboard-coding-system 'utf-8)
  (prefer-coding-system 'utf-8)

  ;; I'm into Perl, but prefer cperl-mode over the default
  (defun modify-alist (alist-symbol key value &optional search-cdr)
    (let ((alist (symbol-value alist-symbol)))
      (while alist
        (if (eq (if search-cdr
                    (cdr (car alist))
                  (car (car alist))) key)
            (setcdr (car alist) value)
          (setq alist (cdr alist))))))
    
  (modify-alist 'interpreter-mode-alist 'perl-mode 'cperl-mode t)
  (modify-alist 'auto-mode-alist        'perl-mode 'cperl-mode t)

  ;; the one true indentation level
  (setq cperl-indent-level 4)

  ;; Don't mix tabs and spaces
  (setq-default indent-tabs-mode nil) 
  
  ;; Use "newline-and-indent" when you hit the Enter key so
  ;; you don't need to keep using TAB to align each line.
  (global-set-key "\C-m" 'newline-and-indent)

  ;; Get rid of the <2> with duplicate file names
  (require 'uniquify)
  (setq uniquify-buffer-name-style 'post-forward-angle-brackets)

  ;; Use "newline-and-indent" when you hit the Enter key so
  ;; you don't need to keep using TAB to align each line.
  (global-set-key "\C-m" 'newline-and-indent)

;; Switch buffer

(global-set-key [f5] 'buffer-menu)

;; Save and load

(global-set-key [f2] 'save-buffer)

(global-set-key [f3] 'find-file)

;; Compile file

(global-set-key [f9] 'slime-compile-and-load-file)

;; Goto line

(global-set-key "\M-l" 'goto-line)

;; Go to other window

(global-set-key (kbd "<C-tab>") 'other-window)

;; And probably the most useful one, numpad Enter for eval line:

(global-set-key (kbd "<kp-enter>") 'slime-eval-last-expression)

(setq transient-mark-mode t) ; visually show region

(setq line-number-mode t) ; show line numbers

(setq global-font-lock-mode 1) ; everything should use font

(windmove-default-keybindings) ; shift-arrow key moves to window in that direction

I set up `webjump' to search online API documentation

http://justinsboringpage.blogspot.com/2009/05/emacs-searchin...

I like to send gmail

http://justinsboringpage.blogspot.com/2009/02/sending-mail-w...

I think this is the most important one

(setq visible-bell t) ; annoying beeps off

Granted, you could probably do that with transient mark mode, but seeing everything highlighted would be too annoying.

http://www.nongnu.org/bm/

  (defun my-git-root () 
    (if buffer-file-name
        (let* ((current-directory (file-name-directory buffer-file-name))
               (git-directory (concat current-directory ".git")))
          (while (and 
                  current-directory 
                  (not (file-exists-p git-directory)))
            (setq current-directory (file-name-directory (substring current-directory 0 -1)))
            (setq git-directory (concat current-directory ".git")))
          current-directory)))

  (defun sudo-find-file (file-name)
    (interactive "FFind file (sudo): ")
    (find-file (concat "/sudo::" file-name)))

  (defun go-to-doc (base-url)
    (let ((default (symbol-name (symbol-at-point))))
      (browse-url (concat base-url (read-string "Search term: " nil nil default)))))
  
  (defun rails-doc ()
    (interactive)
    (go-to-doc "http://apidock.com/rails/search?query="))
  
  (defun ruby-doc ()
    (interactive)
    (go-to-doc "http://apidock.com/ruby/search?query="))

  (when
      (load
       (expand-file-name "~/.emacs.d/elpa/package.el"))
    (package-initialize))

  (server-start)

Now, I used to work for Google and most people there let you see their own home directories and I used that as an opportunity to learn from Stevey's setup.

There are a lot of customization going on and I should do a separate blog post about the setup. Here are I just cherry-picked some recent configuration favorites of mine:

  ;; 
  ;; Superb way to move between Emacs windows
  ;; Shift+arrow keys
  (windmove-default-keybindings)

 ;; Resize emacs according to the display resoluton
 (defun set-frame-size-according-to-resolution ()
   (interactive)
   (if window-system
   (progn
     (if (> (x-display-pixel-width) 1900)
         (add-to-list 'default-frame-alist (cons 'width 260))
       (add-to-list 'default-frame-alist (cons 'width 80)))
     (add-to-list 'default-frame-alist 
                  (cons 'height (/ (- (x-display-pixel-height) 50) (frame-char-height))))
     (add-to-list 'default-frame-alist 
                  (cons 'top 10))
     (add-to-list 'default-frame-alist 
                  (cons 'left 5)))))

And then I have this in my .emacs:

    (require 'anything-config)
    (global-set-key "\C-c\C-a" 'anything)
    (global-set-key "\C-c\C-e" 'anything-for-files)

    (defun anything-for-files-create-if-not-found ()
  "Just like anything for files, but gives the option to create a file."
  (interactive)
  (anything '(anything-c-source-ffap-line
              anything-c-source-ffap-guesser
	      anything-c-source-regular-filename-completion
              anything-c-source-recentf
	      anything-c-source-file-not-found
              anything-c-source-buffers+
              anything-c-source-bookmarks
              anything-c-source-file-cache
              anything-c-source-files-in-current-dir+
              anything-c-source-mac-spotlight)))

http://bitbucket.org/[redacted]/dotfiles/src/tip/.emacs.d/pl...

Probably my favorite bit of the config is that it uses flymake to run Pyflakes on my Python code as I'm writing it. I also have a little plugin that shows the error in the minibuffer area when the point is over the offending line.

It also disables backup/autosave file littering by using a locked down directory in /tmp.

As far as bindings go, I wrote delete-backward-indent for python-mode which deletes a level of indentation instead of just one space. There's also newline-maybe-indent that doesn't indent if the previous line has no indentation.

Everything else is pretty straightforward customization, I think. flyspell-prog-mode is another thing worth mentioning: it highlights spelling errors, but only in strings and comments.

   (add-hook 'c-mode-common-hook
	  (lambda ()
	    (font-lock-add-keywords nil
	     '(("\\<\\(FIXME\\|TODO\\|BUG\\):" 1 font-lock-warning-face t)))))

   (setq load-path (append load-path (list "/Users/diN0bot/.emacs.d")))

rebindings are useful, such ctrl-q for M-x goto-line: (global-set-key "\C-q" 'goto-line)

I cribbed the following from someone else, but i find it most awesome:

; ===== Put auto-save, backup files in one place ===

;; Put autosave files (ie #foo#) in one place, not ;; scattered all over the file system! (defvar autosave-dir (concat "/Users/diN0bot/.emacs.d/auto-save-list/"))

(make-directory autosave-dir t)

(defun auto-save-file-name-p (filename) (string-match "^#.*#$" (file-name-nondirectory filename)))

(defun make-auto-save-file-name () (concat autosave-dir (if buffer-file-name (concat "#" (file-name-nondirectory buffer-file-name) "#") (expand-file-name (concat "#%" (buffer-name) "#")))))

;; Put backup files (ie foo~) in one place too. (The backup-directory-alist ;; list contains regexp=>directory mappings; filenames matching a regexp are ;; backed up in the corresponding directory. Emacs will mkdir it if necessary.) (defvar backup-dir (concat "/Users/diN0bot/.emacs.d/backup-file-list/")) (setq backup-directory-alist (list (cons "." backup-dir)))

(fset 'yes-or-no-p 'y-or-n-p)

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

most useful parts: replacing fundamental mode with text-mode as the default mode when a new buffer is open.

(setq default-major-mode 'text-mode)

turn auto fill (automatic line wraping) and flyspell (spellchecking) on by default

(add-hook 'text-mode-hook 'turn-on-auto-fill)

(add-hook 'text-mode-hook 'turn-on-flyspell)

also I find yasnippet http://code.google.com/p/yasnippet/ wonderful for coding html mockups and django templates.

my github repo if anyone cares to take a peek: http://github.com/bmac/emacs

As folks successively quote each other in a thread, the prepending of '>' to the quoted text requires something narrower than 80, else it'll hit the 80-chars-wide limit and wrap.

72 would allow 4 or 8 quote-levels, depending on if your client decides to insert spaces around the '>'.

Mine's pretty minimal at the moment, but it does the job.

delete-delete-delete save-buffer Much better.

I hear ya.

One of the things I started doing lately is not moving any dotfiles automatically when I get a new machine. After 3 days of moaning, I go and dig out just the stuff that I have noticed I am missing. (I do the same for firefox plugins and so on). It has definitely helped with the historical crud.

(require 'activator) (activator-start)

Which then looks at all of the stuff here: http://github.com/apgwoz/emacs-config

http://github.com/larrywright/emacs

The default undo history is only 32. I like to be able to go further back.

    (require 'ido)
    (ido-mode t)

(defun init-streamfocus () (interactive)

;; Slime is for starting or connecting to SBCL ;; To start: C-x slime RET (add-to-list 'load-path "c:/Otech/sf/lib/slime")

;;(setq inferior-lisp-program "C:/Otech/programs/sbcl-1.0.9/sbcl")

                                        ;(setq inferior-lisp-program "C:/Program Files/LispWorks/lispworks-4450")

;;;For SBCL on Windows ;(setq inferior-lisp-program "sbcl") ;(add-to-list 'load-path "C:/Program Files/Steel Bank Common Lisp/1.0.22/sbcl.exe")

;;For Allegro on Windows (setq inferior-lisp-program "allegro") (add-to-list 'load-path "C:/Program Files/acl81/allegro.exe")

(require 'slime) (slime-setup '(slime-fancy slime-banner))

;;allegro (global-set-key "\C-cs" 'slime-selector) (setq slime-complete-symbol-fancy t) (setq slime-complete-symbol-function 'slime-fuzzy-complete-symbol)

(setq slime-multiprocessing t) ;; choose one of the below based on Express or non-Express usage ;(setq slime-lisp* "alisp.exe") (setq slime-lisp "allegro.exe")

  ;;(setq *slime-lisp* "allegro-express.exe")
  (setq *slime-port* 4005)
  
  (global-set-key
   [(f5)]
   '(lambda ()
      (interactive)
      (shell-command 
       (format "%s +B +cm -L c:/.slime.lisp -- -p %s --ef %s &"
               *slime-lisp* *slime-port*
               slime-net-coding-system))
      (delete-other-windows)
      (while (not (ignore-errors (slime-connect "localhost" *slime-port*)))
        (sleep-for 0.2))))  
  
  (let* ((cygwin-root "c:/cygwin")
         (cygwin-bin (concat cygwin-root "/bin")))
                                        ;(setenv "HOME" (concat cygwin-root "/home/frederick"))
    (setenv "PATH" (concat cygwin-bin ";" (getenv "PATH")))
    (setq exec-path (cons cygwin-bin exec-path)))
  (setq shell-file-name "bash")
  (setq explicit-shell-file-name "bash")
  
  (push ".fasl" completion-ignored-extensions)
  (push ".git" completion-ignored-extensions)

  ;;--------------------------------------

  (defun slime-connect-to-host (path port)
    (setq *current-tramp-path* path)
    (setq slime-translate-from-lisp-filename-function
          (lambda (f)
            (if *current-tramp-path*
                (concat *current-tramp-path* f)
              f)))
    (setq slime-translate-to-lisp-filename-function
          (lambda (f)
            (if *current-tramp-path*
                (substring f (length *current-tramp-path*))
              f)))
    (slime-connect "localhost" port))
  
  (defun cayenne-slime ()
    (interactive)
    (slime-connect-to-host *cayenne-path* 4006))
  
  (defun cayenne-find-file ()
    (interactive)
    (find-file (concat *cayenne-path* "/home/streamfocus/sf/")))
  
  

  ;; http://www.emacswiki.org/cgi-bin/wiki/NTEmacsWithCygwin
  (let* ((cygwin-root "c:/cygwin")
         (cygwin-bin (concat cygwin-root "/bin")))
                                        ;(setenv "HOME" (concat cygwin-root "/home/fred"))
    (setenv "PATH" (concat cygwin-bin ";" (getenv "PATH")))
    (setq exec-path (cons cygwin-bin exec-path)))
  (setq shell-file-name "bash")
  (setq explicit-shell-file-name "bash")
  )

  ;; swank-clojure
  (add-to-list 'load-path "C:/Otech/programs/clojure/swank-clojure")
  (require 'swank-clojure-autoload)
  ;(swank-clojure-config
   (setq swank-clojure-jar-path "C:/Otech/programs/clojure/clojure/clojure.jar")
   
   (setq swank-clojure-extra-classpaths
         (list "C:/Otech/programs/clojure/clojure-contrib/clojure-contrib.jar"))
   ;)
  
  ;; slime
  (eval-after-load "slime"
    '(progn (slime-setup '(slime-repl))))
  
  (add-to-list 'load-path "C:/Otech/programs/clojure/slime")
  (require 'slime)
  (slime-setup) ;;;type alt-x and slime to start repl
  )