Saturday, February 6, 2010

Emacs baggage

In a prior post, I articulated why I liked Emacs. There are plenty of reasons, certainly! This week, however, I rethought of my decision to switch completely over to Emacs. It has a lot of baggage holding it into the past, and I get the feeling it needs to be reborn (an Emacs rewrite in clojure would be awesome). Leaving Emacs and returning back to my TextMate editing environment has turned out to be a relatively good experience: even though I miss a few features, I don't miss the fiddling.

I really did give Emacs a fair shake. I wrote a campfire mode (a chat client for 37 signals campfire right within Emacs), contributed several improvements to a few scripts, submitted a variety of scripts to the ELPA, and otherwise invested a plethora of hours into learning it.

At first, the cool features that Emacs has kept me going. It was a lot of investment, and I found myself thinking "it will get easier, the overhead will go away". After two months, it still hasn't. Emacs is full of 80% complete features, so lots of things bugged me, constantly requiring my attention to fix. When you fiddle with Emacs, some issues don't manifest themselves until the next time you try to start it. Therefore, every time I started up Emacs, something would fail somewhere. In the end, this was throwing gravel into the engine of my productivity.

Another thing I noticed: my wrists seemed to have more problems when I was using Emacs. For whatever reason, TextMate seems to be easier on my wrists. TextMate might require more keystrokes then Emacs to perform certain editing tasks, but the movements aren't as awkward.

There is no question that Emacs is more extensible than TextMate or vim. But, in the end, even after several months of usage, I still found myself more productive using simpler editors that just worked well out of the box.

I will probably continue to use Emacs in some form or another, probably for LaTeX and Clojure. For really quick editing jobs, I still prefer vim, because it is really powerful and starts up fast. But, as far as Ruby on Rails development goes, I'm not sure it gets any better than TextMate.



Daniel said...

You've obviously put some thought into this. (What software do you use to create your mindmaps btw?)

The constrast between extensions that programmatically extend the editor versus declaratively (emacs vs. textmate/padre) is something I've been thinking about for Redcar. (Point 7?)

I'm trying to move Redcar plugins over from having a 'start' method that does a bunch of stuff, like add stuff to menus, to having plugins declare: here are my menus, come and get them if you want them.

This makes it a lot easier to do things like plugin reloading and disabling, and should make the editor more robust.

Anyway, thanks for the post.

Tim Harper said...

hey there Daniel,

I'm excited about redcar. Thank you for your work on it! I think it has the potential to be "the one true editor". :-)

I'm using free mind to generate mind maps. To embed it into this blog post, I just uploaded it to and used the embed feature.

Berto said...

I can definitely understand your stance on Emacs. It does have a lot of baggage and in TextMate I felt I could whip up snippets and such quicker than I can in Emacs. But, for the work I do (mainly python) TextMate just doesn't cut it, so I've stuck to Emacs. If there was a powerful editor that handled Python better, I'd likely switch. TextMate was almost there, but not quite. The excessive whitespace it left in python code is simply undesirable when you work on a team of people collaborating on the same project.

I've been an emacs user for a long, long time and I have simply not come across a lot of the things you outline in your post. For instance, instability after restarting; that's crazy. Maybe I don't have as many add-ons, or the magic combo of add-ons that exhibit the problem.

Another is binding command-control-k, that works just fine for me; I just tried using this as an example in the *scratch* buffer and then executing the line by putting the cursor at the end of the line and typing C-x C-e:

(global-set-key [(control meta k)] 'find-file)

The reason I initially switched away from Emacs was that I developed a striking pain in my left hand (likely pinky holding ctrl down all the time), so I know where you are coming from. I should have thought of this sooner, but I solved the problem by eliminating the key bindings that were causing problems:

- eliminated ctrl-n, ctrl-p, ctrl-f, ctrl-b so I was forced to use the arrow keys instead.

- bound save and open to cmd-o and cmd-s, which got rid of excessive C-x C-f and C-x C-s

- rebound caps lock to control, which reduced the distance to the control key for other things (note: this really messes with you when you use other computers)

This brings up another point you make: you don't have the same keybindings on other machines. I suppose that's a drawback, or it's the advantage of being able to taylor the editor to your needs; the same can be said for TM bundles that you develop and are not available on other TM installs.

In any case, here is my "save the pinky" section in my .emacs:

;; force myself to use arrow keys so that I don't
;; mash the control key with my pinky 90% of the time I am using$
;; emacs.
(defun save-the-pinky ()
"Echo out message to echo area"
(message "Use the arrow keys!")

(global-set-key [(control n)] 'save-the-pinky)
(global-set-key [(control p)] 'save-the-pinky)
(global-set-key [(control f)] 'save-the-pinky)
(global-set-key [(control b)] 'save-the-pinky)

;; other nice OS X keyboard behaviors
(global-set-key [(meta s)] 'save-buffer)
(global-set-key [(meta z)] 'undo)
(global-set-key [(meta down)] 'end-of-buffer)
(global-set-key [(meta up)] 'beginning-of-buffer)
(global-set-key [(meta right)] 'end-of-line)
(global-set-key [(meta left)] 'beginning-of-line)
(global-set-key [(meta o)] 'find-file)

;; setup some shortcuts for os x with the option (hyper) key
(setq mac-option-modifier 'hyper)

(global-set-key [(hyper left)] 'backward-word)
(global-set-key [(hyper right)] 'forward-word)
(global-set-key [(hyper backspace)] 'backward-kill-word)
(global-set-key [(hyper r)] 'point-to-register)
(global-set-key [(hyper j)] 'jump-to-register)

I've been using Carbon Emacs, by the way (, maybe it's the version of Emacs you're using? You mention the desire of an Emacs reincarnation, so to speak, have you seen Aquamacs: I must be stuck in my ways because I've tried Aquamacs a couple of times and simply can't get used to it; but it might work for you.

Hope this helps you, and if you know of a nice modern editor that's good for python, let me know! Maybe I should give aquamacs a shot again and start with a clean .emacs file.

Unknown said...

the correct link to Aquamacs is