So far (the short version) I am doing better than I thought for just about a couple of days being serious about this. There are a few things that still bother me a lot though, aside from the fact that I am not proficient using it yet, of course.

My [mostly borrowed] customizations

I’ve heavily customized Emacs to suit my needs better than it could do with its awkward defaults. Emacs key shortcuts (or is it key bindings?) are soooo unpleasant, unintuitive, lengthy and annoying that I refuse to use them at all. Happily one of Emacs’ most powerful strengths, its ability to be customized, comes to the rescue. Actually this feature is what makes Emacs still relevant after 30+ years.

My Emacs after being customized

Without going too much into details, I based my Emacs customizations mostly on Ryan McGeary’s, mostly because his setup is aimed at Ruby on Rails development and Git, which is what I want Emacs for in the first place. Overall, it’s ri-emacs, rinari, rhtml-mode, magit, yasnippets, and several other non-language-specific customizations (ido, recentf, etc.)

On top of this setup, and after pruning stuff that I don’t need, at least for the moment (like erlang, markdown, haml, svn, carbon-emacs, etc.) I added support for some other stuff, namely rspec, cua-mode (see Common User Access), and other minor goodies from other sources.

Aside from McGeary’s setup as a base, I have to give credit to snippets of code I borrowed from elsewhere to further customize my environment. I should particularly mention Devcraft’s advises to customize Emacs for Rails development, Dahoiv’s .emacs file, the Emacs blog (where Ryan McGeary also writes) and the emacs-flu blog.

Pros and Cons

On the good side, I have played for a while with the ruby on rails mode and it is good. The yasnippet extensions take a lot of credit on this, but overall it tastes very good on its own. I have yet to deal enough with the magit extension to fully evaluate my environment. I cannot afford buying a Mac+TextMate for Ruby development, and Emacs can hopefully come to the rescue for my productivity and joy while coding.

Also, having been able to get rid of most of the many painful key bindings in such a short time was amazing. I wonder why Emacs does not update its defaults to comply with the CUA standards. The cua-mode is not enough.

On the bad side (taking aside my own inexperience and lack of abilities) not everything is doing fine. Many of my key-bindings customizations break on “weird” modes, like C-w for closing the current buffer, which is not working when the current buffer is in dired mode.

Also, I feel disappointed with the embedded shell (M-x eshell). I actually expected a bash session inside an Emacs window, but aliases and tab-completion are not working as they should, which makes me suspect it is not bash but an Emacs shell program (surprise!!!). As it is right now, I prefer to Alt-Tab to my terminal emulator with a real bash session in it. Something similar happens with the Rails console (available via C-c ; c), which I really didn’t test a lot after I realized that pressing the up and down arrow keys didn’t navigate through my history of previous commands .

So, what is it then?

In spite of all this, I still believe I can give Emacs a chance. Most shortcomings I’ve faced are not directly related to its function as a coding environment, but to tasks around coding, like going to the console to type rails-related commands, manipulating the file system, etc. I was doing these stuff outside my previous code editors anyway so I guess this can stay as is for some time.

Hopefully I’ll be able to fix some of this issues over time and always use more and more features of this wonderful editor. I could even live without using git from within it, but I have yet to test that. Meanwhile, I’ll take some time to get better at coding with what is currently working for me. It seems to me that Emacs will stay for a while on my desktop.

Or so I though… until recently. It turns out that to be sure, I searched for command-line bookmarks on google and after a while digging for it, I managed to find three different projects that aim at providing this feature to my favorite shell.

I downloaded and installed all these packages and I am sharing my thoughts about them here.

go-tool

go-tool

This was the first one I found and the one I have used the most. The project is hosted at http://code.google.com/p/go-tool/ and it is developed in Python.

It has a command-line automated setup process that installs the python module system-wide, and there’s also a command to automatically setup shell integration.

Shell integration is achieved by registering some bash functions that do the actual directory change (this is needed because spawned processes do not change the working directory of the parent process, so a python script cannot actually change the working directory of the shell session that started the script). As you can imagine, this feature is common to all the three projects.

Directories are aliased to a short keyword that you can later use to change your current directory. You can add a bookmark for the current directory, or for any other directory, you can delete bookmarks, etc. The details are better covered in the project’s homepage.

The main downside of this solution is that once you start using it, you start missing bash completion with the TAB key. Although I guess it shouldn’t be difficult to implement it ourselves. The program stores its bookmarks in ~/.go/bookmarks. The main advantage is that it is multi-platform, supporting Unix-like environments (including Apple’s Mac) and Windows.

CDBM

cdbm

The name is an acronym for ‘cd bookmarks’ and the project is hosted at google code too (http://code.google.com/p/cdbm/) although I found more information about it from its author’s blog. It is programmed in c.

This is the most simple of the three projects I found. It is simple to install and simple to use, but it is also the simplest in terms of features and possibilities, although unlike the previous one, it features auto-completion.

Shell integration is achieved in a similar way, through bash functions that have to be programmed into our ~/.bashrc file.

Its main disadvantage is that is oriented to bookmarks indexed by numbers instead of aliases or keywords. In a more recent version the author added keyword support on top of the previous design, without removing the numeric index. However, keywords support still doesn’t feel natural.

Apparix

apparix

This was the last project I found and it is the most complete in terms of features. It is hosted at http://www.micans.org/apparix/ and implemented in c as well.

It features shell integration, bash auto-completion support, and it extends bookmarks to more than just a simple super-cd utility. For instance, bookmarked directories’ contents can be listed remotely, without actually changing the current directory.

Shell integration si great, but its configuration could be more automated into the setup process, like the go-tool project does. But the bundled auto-completion is great. You can even auto-complete further into the subdirectories of the bookmark you are using in the command.

Take a look at the following sequence of commands:

ernesto@ubuntu:~$ cd /var/cache/
ernesto@ubuntu:/var/cache$ bm
added: cache - /var/cache
ernesto@ubuntu:/var/cache$ apparix
--- portals
--- expansions
--- bookmarks
j cache        /var/cache
ernesto@ubuntu:/var/cache$ cd
ernesto@ubuntu:~$ to cache apt/archives/partial
ernesto@ubuntu:/var/cache/apt/archives/partial$

We change into the /var/cache directory, and then we register a bookmark for it with the 'bm' command. The 'apparix' command then lists the available bookmarks, where you can see our recent addition. Then we go back to our home directory, and use the 'to' command to change into a subdirectory of the directory represented by the bookmark, instead of just changing into the bookmarked directory only.

And the winner is…

Clearly apparix is the most complete of the three alternatives I found, although I have been using the go-tool for some time already, and I was getting used to it. However, I always missed auto-completion for the go-tool, never decided to implement it my self, and now that I have found apparix with it, I guess I’ll make the switch.

You go and play with them and make your own choice. The command line will never be the same after you start using this.