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

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

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

  ;; 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)

delete-delete-delete save-buffer Much better.

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.

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

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

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

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

  ;; 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)

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

(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://github.com/larrywright/emacs

(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

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

;; 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)

(require 'activator) (activator-start)

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