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

You don't like LaTeX-math-mode (bound to C-c ~)?

My .emacs is on GitHub: http://github.com/avar/dotemacs/blob/master/.emacs along with the elisp library I use http://github.com/avar/elisp

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 "^;;;;+"))

Which shows the outline of the file, e.g.:

    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

A quiet startup:

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

Core UI settings:

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

Changing the switching is worth it, but I really need to find something that allows me to between different possibilities once completion is exhausted, e.g. if I say "foo.c" and have both "foo.c" and "foo.c.txt":

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

I wish I could also turn off the annoying #-files, but they're hardcoded in Emacs's C code:

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

Better file selection:

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

I didn't write this, but it's very useful. It emulates vim's sofftab feature. So indenting with spaces doesn't suck anymore.

    (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 "") 'backward-delete-whitespace-to-column)

I really wish I could find something for Emacs which automatically detects the style of the code I'm editing and switches the coding style to that.

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)

I have something to make swank work with clojure and sbcl, but it's too large to include here. clojure-mode et al make it really hard to do this, unfortunately (upstream isn't really interested in this use case):

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

You should use nopaste.el (shameless plug): http://github.com/avar/nopaste

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

Here's how I still tolerate GMail and other web apps. I can click on any text field in Chrome and edit it in Emacs:

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

And this has saved my many a time from losing web form content (I should really make this use Git):

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

Install browse-kill-ring.el now:

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

That's about it for the really interesting stuff. But there's a lot of other mundane stuff in there.

Oh boy, nethack_el does not play well with `longlines-show-hard-newlines`.

I have my own preferred color scheme, won't bore you. At bottom, it's GhostWhite on black.

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)

Emacsclient is a real must.

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

All my shells run inside of Emacs. So they're named, I get completions, and so on. That includes remote shells, using tramp and ssh-mode.

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

Here's what I use for session.

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

With iswitchb, once completion is exhausted try using cursor left and right to switch between the remaining alternatives.