So you have a big test suite that takes over 10 minutes to execute and you wonder if there is anything you can do to help make it faster? Here is something we have been working on for over an year now and we call it TLB. TLB is actually an acronym for Test Load Balancer, but we like to use TLB for convinience and carbon footprint reasons. It is an open-source, BSD licensed tool that splits the load of test execution to make several chunks(that we call partitions), hence allowing your tests to execute parallely, across several physical machines or VMs, with each one executing only one small chunk(one partition).

In short, here is what the tool can do for you:
Say, you have a project with 1000 test-suites, that takes about 10 minutes to execute. With a few lines worth of changes in your build script, and 4 more computers to deploy for the job, TLB can help you bring total time down to 2 minutes. We call this time-balancing. It partitions your test in such a way that all partitions have equal amount of load in terms of time. This implies all partitions take almost the same time to complete, and given that each partition only runs 1/5(one fifth) of the whole, it takes only 1/5th the time, thats 10 minutes/5, which brings us to the 2 minutes number. Similarly if you have a test-suite that takes 5 hours, it can be cut down to just 20 minutes with 15 machines to parallelize it.

Alright, thats exciting, how do I use this thing, you ask? Lets first understand what TLB does not do. TLB does not launch multiple processes across machines, it does not invoke your build task nor does it manage machines for you to run your build on. There are very good tools around that can help you do all of that. You use the tool of your choice to invoke build task, i.e. ‘ant test’, ‘rake spec’ or ‘buildr test’ etc. For instance, the launching of processes across different physical machines at the same time can be offloaded to CI server(like Hudson or Go) or a command-line driven tool like Capistrano or Cluster-SSH. Once the build task(ant or rake invocation for example) is triggered on multiple machines, each one of these processes executes only a part of the whole set of tests. By design, TLB is really non-intrusive, all that changes is a few lines in the project’s build script.

The only other piece that you need in addition to invoking your build task is a daemon we call TLB Server. This is a repository where data captured while running tests(for instance, running time, result etc) is stored. Some algorithms(eg. time-based partitioning or failed-first orderer etc) depend on such data. TLB can either work against an instance of TLB Server or Go Server. TLB server is a part of the TLB project and is available as download(you want to check tlb-server or tlb-complete archive). Go is a ThoughtWorks Studios product and it is a continious integration and release management application. You can use the utility script that server archive bundles to manage the TLB server process. Please check documentation page(this is a release specific link, points to 0.3) for details on both configurations.

Multiple partitions of a build obviously need to use the same TLB server instance, which means TLB server must be reachable over the network from all machines that are to execute partitions of a project’s test suite. One TLB Server instance can be shared by several projects or multiple builds of the same project. This means all projects and builds can share a single organization-wide/office-wide TLB server. TLB server binds to port 7019(unless overridden), so you’d want to unblock that port for inbound traffic on any firewalls/filters on the server machine(similarly you’d want to unblock it for outbound traffic on machines that are going to execute the partitions). I emphasize this here because sometimes firewalls can be really nasty and confusing.

The Java support library in the latest release of TLB(version 0.3) supports popular Java build tools Apache Ant and Apache Buildr. The Ruby library bundles support for Rake. On the testing framework side, TLB has support for widely used Java testing tools named JUnit and Twist and the Ruby library bundles support for two most popular testing frameworks named Test::Unit and RSpec(both 1.x and 2.x). The next TLB release(0.4) will include support for Maven(a Java build tool) and Cucumber(a Ruby testing tool) among other features.

You can download the latest TLB distribution from http://code.google.com/p/tlb/downloads/list. Ruby support is available as rubygems(namely tlb-testunit, tlb-rspec2 and tlb-rspec1). The archive named setup-examples bundles tiny projects we use for demonstration purpose. Each project is a unique language, testing-framework and build-framework combination and has a shell-script named run_balanced.sh that can be executed to have TLB make partitions of test-suite and execute them serially, one after another. The shell script, in short, just starts the TLB server and executes test-task with the appropriate environment variables set. In a real world situation, each one of these partitions would be executed on different machines/process-trees, parallely. To have ant-junit example run for instance, you’d want to:

$ wget http://tlb.googlecode.com/files/setup-examples-g0.3.0.tar.gz
$ tar -zxvf setup-examples-g0.3.0.tar.gz
$ cd setup-examples-g0.3.0/examples/ant_junit
$ ./run_balanced.sh #count balances due to lack of data
$ ./run_balanced.sh #time balances (has data from the previous run)

The last(and of-course second-last) step should make two partitions and execute them one after another. While executing tests, the script also prints messages to help user understand major life-cycle events.
To try out rspec2 integration, you’d want to do something similar to:

$ gem install tlb-rspec2
$ cd setup-examples-g0.3.0/examples/rspec2_example #assuming you already unarchived
$ ./run_balanced.sh #will count balance
$ ./run_balanced.sh #will time balance

Note: Because TLB does not have the necessary data to partition tests accurately(use time-balancing algorithm) when the very first invocation is made, it uses count-balancing algorithm, you need to run the script twice to actually see it time balance. Expect this behavior on your actual project as well, as in, the very first time you execute your build against a new TLB Server, balancing will not be as accurate. Second time onwards it will do a much better job.

The distribution archive named tlb-complete bundles all TLB artifacts(java support library, TLB server, alien support library(only developers adding support for new non-jvm languages would be interested in alien library), setup-examples etc). Other archives bundle subset of complete. Please check the README file on downloads page for details.

Quick Start on the TLB website is usually a good place to get started in just a few minutes. However, we highly recomend going through the Concepts and Configuration pages as well, which explain details that will allow you to tweek your TLB configuration to suit your project, tool-set and environment and zero out any potential impedance mismatch. Concepts documentation is also the first step to enhancing TLB. For instance, if you come up with an algorithm that suites your project better, you can implement it in Java and have TLB use that insteed of the canned ones. Detailed documentation(this is a release specific link, points to 0.3) covers all knobs you can tweak and explains the effect and implication of choices you make.

The setup-examples also come in handy while setting-up TLB on a new project. We recomend borrowing build script snippts from the corresponding dummy-projects(in setup-examples or tlb-complete archive) while trying to wire TLB up for your project(s). Once you are done configuring your project(you have imported the libraries and tweaked the build script) to use TLB, you’d want to refer to Configuration Section(release specific link, points to 0.3), which enumerates and documents configuration parameters.

Here is the slide-deck we use to drive TLB talks. This gets into a little bit of TLB internals, and should help you understand TLB better. This post is only meant to be a quick introduction to TLB and is not exhaustive, please refer to TLB website for exhaustive documentation and other details. Should you have any questions/queries, feature-requests, feedback or suggestions related to TLB, feel free to reach us at test-load-balancer@googlegroups.com.

So go ahead give your test-suite rocket boosters and watch it fly by. Happy TDDing!

I have tried installing it atop Wine which in-spite of my best efforts didn’t work, so its not worth wasting your time with Windows version. On the RSA website i came across this J2ME version(the one thats supposed to work on java enabled mobile phones). I came across this project called MicroEmulator which emulates java enabled phone like environment and allows development and testing of J2ME applications. This is what it took me to get it working on GNU/Linux.

$ java -version
java version "1.6.0_20"
Java(TM) SE Runtime Environment (build 1.6.0_20-b02)
Java HotSpot(TM) Server VM (build 16.3-b01, mixed mode)

$ java -cp microemulator-2.0.4/microemulator.jar:SecurID.jar org.microemu.app.Main com.rsa.swtoken.j2me.client.SecurID


This should bring up the emulator X window. Lets drive the process further using screenshots, as its GUI intensive hence harder to communicate and understand.

Image 1: Emulator launched with SecurID Token application
Image 2: Shows welcome screen after accepting license.
Image 3: Chooses a more comfortable layout from Options -> Select Device as default device.
Image 4: Chooses ‘Numeric Input’ over ‘Web Download’(which i couldn’t get to work).
Image 5: Shows screen prompting for Numeric Input.
Image 6: Shows screen Numeric Input prompt filled with numbers we captured in /tmp/17_parts.
Image 7: Shows the screen post entering Numeric Input (with password ‘password_you_got_from_admin’ populated)
Image 8: Finally, token added successfully.
Image 9: Prompts for pin (this was a 4 digit number in my case)
Image 10: Displays the 8 digit number you need to use as password to vpnc(or Cisco VPN Client/nm-applet vpnc plugin etc) to connect to vpn.

This pain and aggravation we just went through is one time only(what we just did was import the token, and we don’t need to do this every day). You will however need to type the ‘password_you_got_from_admin’ every time, in order to get it to prompt for the 4 digit pin. Quit the emulator at this point and relaunch it(using command $ java -cp…) to see what i mean.

Unlike every other post i wouldn’t end this one with “Happy VPNing” because i know VPNing can never make you happy(or at-least not if you are like me). However this should help make the procedure to connect to VPN shorter for you. In my case it reduced from “requesting Sweta(my wife) to launch the SecurID app on her laptop(which has OS X) and dictate me the number(which obviously wasn’t as easy when she was not around)” to invoking “java -cp …”.

Its funny that Proprietary software makers go this length to make life difficult for Free Software users(and we still get around it). In this case it so happens that RSA has SecurID app for Windows, OS X, Blackberry, Symbian(which doesn’t work BTW…) and J2ME platform but not for GNU/Linux or BSDs. They support all operating systems but the best!

I have tried this setup on my laptop which runs 32 bit Gentoo, but these steps should work on any other *nix flavor that has sun jvm installed. I tried the web-download method for adding token as well, but couldn’t get it to work and didn’t know what the problem was. Will post what i did for web-download as a comment on this page sometime soon(and hope someone helps us by hacking it and getting it to work). I don’t know about you, but keying-in the 17 sets of wierd numbers was the most painful part of this whole exercise for me.

Recently my colleague(Chris Turner) introduced me to tmux which happens to be the best terminal multiplexer i have seen till date. It not only supports vertical splitting in addition to everything else that i love screen for, but has inbuilt emacs and vi style keymaps, which means i can use emacs like shortcuts while in copy mode. In addition to that, it remembers window layout across multiple panes, even for detached sessions and that is a big advantage over screen for managing sessions on remote machine. Tmux comes with quite bare-bone default setup, but its power must not be underestimated. Here is a screenshot of what my tmux(running within gnome-terminal) looks like. I find this setup way more productive compared to its powerful predecessor screen, let alone terminal emulators like Terminator.

Here is my .tmux.conf. Feel free to use it if you like my setup(gentoo portage tree had tmux 1.1 at the time of writing this post, so this config may require some tweaking to work with older releases). I use Ctrl+j as escape sequence, as both keys are on the home row its really convenient(if you are like me, i can safely assume you have Caps lock swapped with Ctrl). Besides, it doesn’t conflict with any of the shell shortcuts that i use. As the screenshot shows, tmux is capable of being screen and a whole lot more.

I have a little function named ‘x’ added to .zshrc which helps me transfer text selected from copy mode to X session clipboard(however, you need xclip installed to use it).

x() { echo $1 | xclip -selection c. }


It took me only a few hours to configure it to my taste and discover the wonderful features that it comes packed with, thanks to the brilliant manpage entry and online help (<Excape seq> + ?). So what are you waiting for? Its time your package manager did the hard work . Give it a few hours, its well worth it. Happy TMUXing!

Problem:
NetworkManager changes the hostname after connecting to wireless network. However, it doesn’t update xauth with the new hostname, which means .Xauthority file is no longer valid once the hostname is changed, and attempts to launch applications fail with ‘no protocol specified/cannot open display’ messages.

Fix:
In my case, i believe, ‘etc-update’ was the culprit. Fix is to update /etc/conf.d/hostname with the desired hostname, which is apparently honored by NetworkManager. Once HOSTNAME is set in the conf-file, and OS is rebooted, ‘xhost list’ can be used to validate the .Xauthority contents and hostname can be matched. X applications should start without any trouble.

Fix:
Some digging up on the web revealed it is a known Dell bios bug, and has been fixed in upstream.  So, the solution is to upgrade bios to latest available version.

Steps to upgrade:
Install ‘libsmbios’:

sudo emerge --sync
sudo emerge libsmbios

…and follow further instructions here: http://linux.dell.com/wiki/index.php/Tech/libsmbios_dellBiosUpdate (this page has steps to download updated bios and install it using dellBiosUpdate (a15 is the latest available release at the time of writing, and fixed the problem for me))(Ignore distribution specific instructions).

• my laptop(Dell D630)(usually runs Gentoo, sometimes Debian-Lenny)
• Sweta(my wife)’s laptop(MacBook Black running OS X Snow Leopard)
• our desktop at home (runs Ubuntu(as of now), which im planning to move to Lenny too, as Ubuntu is obnoxiously irritating)(this one was supposed to be the permanent docking station for the unit as well)

So given the situation, the disk was obviously going to live most of its life flirting with GNU/Linux setups, so it made sense to have it on ext3 (or ext2/jfs/xfs etc?). So, i did the partition tables then mkfs.ext3, some spicing up with tune2fs and after e2labeling it, with some amount of satisfaction mounted the partitions to verify i had done them right.
Having verified disk’s working state, i unmounted and jacked the disk into the MacBook(OS X) which decided not to mount it. dmesg showed kernel figured the disk was there, which indicated to me the reason for it not being mounted(it probably didn’t know what ext3 was). Some reading on internet revealed i needed ext2fsx to save the day. My attempt to install it however, was thwarted with a not so intuitive error message(which gave me no clue as to what the fuck was wrong with my installation). With some frustration, i accepted that user friendly softwares are supposed to obfuscate the error messages/stack traces, so that user gets no fucking clue about failure and has no way to fix it(not quite what i call ‘user friendly’, but whatever). Some more reading indicated i needed MacFUSE and FuseExt2 to do userspace shit since my kernel didn’t think i as someone who paid for the piece of shit(OS X) deserved the right to use other filesystems than HFS+ and crappy windows file systems(like NTFS and FAT32).
FuseExt2 made it work alright, but automount was not writable and doing writable mount required ‘-o force’ option, which essentially meant Sweta had to hit the terminal every time she jacked the disk in, but that was no more than tip of the iceberg. Actually mounting the ext3 volume, as we figured, was a fourty minute process, as you are forced to wait after the mount command returns, for Finder to unfreeze and mounted volume to appear. User friendly, isn’t it?
Having it mounted was however, not the end of my miseries. We tried to transfer a movie(700 odd MBs worth of data i believe), which took forever to get to 33%, not cool by any standards. I finally had to give up and cancel the transfer, and then uninstalled FuseExt2.
Irritated, i popped the Disk Utility app, and started my hunt for options. It seemed to have Ext2 as one of the items in filesystem selection box on the repartition tab, which i decided to go with, only to find it harassing my new disk for one and a half hour without moving the progress bar beyond 50%. I finally ran out of patience and unplugged it. On jacking it into my Dell, fdisk revealed the state of affairs. Mac had made an ass of my disk, the partition table was total mess(and by the way, it hadn’t even begun creating the second partition(i had requested two ext2 partitions to start with). I don’t know what world OS X team lives in, but in the world that i know, it usually doesn’t make sense to write the partition table after formatting the filesystem unless you enjoy doing the same thing over and over. Anyways, i finally had to redo the partition cutting exercise and decided to go with ext2 this time, as it seemed like mac would read that. But guess what?, i jacked the disk into mac only to find out it does not read ext2 either. Fuck! Why does disk utility have an option to create partition using format the OS can’t read?
Annoyed and frustrated, i gave up and decided to have it the Mac way. Once again i resorted to disk utility in order to create 2 Mac Extended(HFS+ partitions). Surprisingly, the partitioning tool that took one and a fucking half hour without completing even one of the two ext2 volumes i requested, managed to finish HFS+ on a 1.5 TB disk under 2 minutes flat.
Those who compile the Linux kernel for themselves know that HFS+ support(under file systems -> miscellaneous…) is not default. You have to enable it and recompile. I had to go back to menuconfig, do the hunting, enable it as a module, make it, modules_install and modprobe it before i could use the fucked up proprietory filesystem the jack-ass created. All because OS X doesn’t know one of the most widely used filesystems in GNU/Linux world(i failed to get any reasons for it supporting NTFS and FAT filesystems inspite of it being a flavour of a very respected Unix distribution, such a bad ass child). Even though i had to compile the module to get things flying, it took me no more than 3 minutes. Thats usability for you.
End of the day, it worked! But i had to compromise. I had to do it the proprietory way, the mac way. You pay for the software and get your license, but even after you own it, you pay every single day, not in terms of money but freedom. You just don’t have a choice. The software decides what you can and can’t do on the hardware you own, and fighting your way through is insanely difficult and grossly unproductive excercise. A good software should always help the user and never come in the way. I don’t know about you, but i do not remember anything ever coming anywhere close to GNU/Linux when it comes to usability.
Software being a dumb-ass tantamounts to it being unusable and un-userfriendly. I can only hope propritory software makers will someday figure what a pain in the butt products they create are, and will start to work towards making user’s life easy and the softwares usable. I really feel sorry for users that have to put up with this kinda shit everyday.

The same executable can be added to session preferences to start pidgin on session load.

...
title           Debian GNU/Linux, kernel 2.6.26-2-686
root            (hd0,0)
kernel          /boot/vmlinuz-2.6.26-2-686 root=/dev/sda1 vga=865 ro quiet
initrd          /boot/initrd.img-2.6.26-2-686
...

Hope this helps someone.

• A good Ruby editor
• Good Haml editor
• Good rhtml/html+erb editor
• Good JavaScript editor
• Terrific auto-completion
• Decent ruby debugging support
• Decent tag navigation(eg. navigating from method/class/module/variable usage to definition)
• Ability run Test::Unit/Rspec tests from the editor
• Ability to show multiple files at the same time(by splitting windows)
• Ability to jump between related files(controller – model – view – spec/test etc)
• Ability to run an interactive ruby console within the editor
• Auto-generatable snippets (some call this one LiveTemplates)

RubyMine has support for certain things like decent ruby editor, showing multiple files at a time(i am assuming it works well, because this was supported in IntelliJ Idea when i used it last), ruby debugging and auto-generatable snippets, but it lacks on certain other fronts. For example, it does not have Haml editor and no key-binding to jump between related entities(controller, model, view, spec, helper etc). However, the major drawback with RubyMine is its resource footprint. I have seen developers force shutdown their OS X (running on MacBook Pro) because RubyMine decided to go unresponsive and `kill -9 <pid>` failed to get rid of it. Even GNU/Linux users are forced to kill it sometimes because it freezes too often(however `kill -9 <pid>` does work reliably on Linux, hence no operating system restart required ). JavaScript support is dumb and doesn’t highlight errors too well. I do give it some points for navigation and searching though.

TextMate unlike RubyMine is light on resource footprint. But unfortunately, it also is low on features. Ruby editor is decent, but auto-completion is retard(it completes words from the current buffer(file) only).  Besides, key binding for auto-complete(which is such a common operation) is Esc(no touch-typist in the sane world would like that). It has no debugging support at all, and running rspec needs a plugin which in turn needs rspec installed as a gem, and if you have a frozen version of rspec/rspec-rails in your application codebase, then tough luck(there is no easy way to configure it to pick things up on a per project basis, you need to roll your sleeves up and dig into /Application/TextMate.app, to modify some badly written ruby/shell-script mess). Navigation and searching is horrible(slow and unintuitive). Command-T has no notion of priority, and brings up all the wrong files first. Haml support has to be installed seperately as a plugin, and is terrible(be it indentation, or syntax hilight). There is no interactive console and no spliting of windows supported.

There is more that i expect from an editor before i call it a good programming environment. Here is what I think my definition of good programming tool looks like(in addition to the features in the bulleted list above):

• Ablity to run multiple terminals within the editor
• Ability to open directories as buffer(allowing easy selection of files)
• Ability to run IRC client(i like to be on IRC channels all the time, helping people and seeking help is a great way to learn)
• Snappy frontend and sensible keystrokes(close to the host row, not forcing user to get out of touchtyping mode too often)
• Straightforward key-bindings for macro record and play.(Both TextMate and RubyMine claim to have Macro support, but its hidden somewhere under the MenuBar-Submenu(s))
• Ability to run commands without leaving the editor or creating a terminal within it.

Emacs is a pretty powerful and mature editor which has passed the test of time and has got several refinements and enhancements over the years it has lived. Most of the major things that i want in my development environment are bundled with Emacs out of the box(and the once that aren’t, are available as plug-ins). I believe the best thing about Emacs is its written in lisp, which means you can change things very easily and cleanly. I do Ruby/Rails development in my day job, and have been customizing my Emacs repository for some time now. Over a period of time, i have accumulated/tweaked some emacs goodies which have not only made Emacs a better Ruby, JavaScript, Lisp, C++ editor, but a better IRC, Mail, RSS, Atom and News client. I keep my add-ons and customizations on github.com as a public repository, which helps me share it with other developers, and also gives me protection against disk failures and other bad things.
So here is what my setup looks like.

• Ruby: ruby-mode(written by Matz) + ruby-electric(minor mode)
• Haml: haml-mode(Nathan Weizenbaum) (by far the best support for HAML syntax highlight and marvelous indentation strictness, people who write haml know how painful it can get in TextMate/RubyMine to hunt bad indentation and fix it, but not with Emacs)
• Rhtml/Erb: rhtml/rhtml-erb (Paul Nathan Stickney) Great syntax highlighting and indentation support.
• JavaScript: I was waiting to come to this one. js2(Steve Yegge) has the best JavaScript editing support I have ever seen. js2 has remarkable indentation, very good syntax highlighting and terrific error detection(warns you even about missing var and semicolons, let alone the more obvious errors).
• Auto completion: Of course. This one works across buffers, across modes and unlike TextMate’s `Esc` the key binding(M-/) is quite sane. You don’t have to go out of touch-typing mode, and the same shortcut can be used to browse through other possible completions.
• Ruby Debugging: rubydb3x to rescue (rubydb2x for Emacs 19.2 and older). Just fire rubydb and get rolling. It uses GUD (Grand Unified Debugger), and has sensible(easy to remember) shortcuts(unlike F7, F8, F9 that most IDE(s) have). Some common key bindings are C-n for next line C-s to step in, C-f to finish function, C-r to resume and <, > to roll stack frames up and down(the name-space used is C-c, so it doesn’t override any of the usual actions that those shortcuts are supposed to perform).
• Tag navigation: Navigation is a breeze. M-. to get to the implementation, M-* to pop out of it. I enhanced it to make it a look recursively up the directory hierarchy to find the tags file(a file named TAGS) and load it up and navigate seamlessly, all by itself. (etags doesn’t have ruby support, so use exuberant-ctags)(“/usr/bin/ctags -e -a –Ruby-kinds=-cmfF -o TAGS -R <dir_name>” can be used to generate a file named TAGS which emacs will read to navigate ruby code).
• Test::Unit/Rspec tests: test-runner(a tiny add-on) runs your test as you load a test file, and then autoruns it every time the test file is saved. It supports Test::Unit by itself, I added support for Rspec(even running single spec) to it. Works like a charm, and is very easy to tweak.
• Ability to show multiple files by splitting windows up: Do i need to say anything about windows support? Emacs is loved for this capability. However, navigation between windows was a bit painful before i added window-numbering.el (Nikolaj Schumacher), which made it sweet.
• Ability to jump between related files: Rinari(Phil Hagelberg, Eric Schulte) uses jump(Eric Schulte) to make jumping between controller-model-view-helper-spec-test on a Rails project seamless and quick.
• Runing interactive console: ruby-mode has a this hook called run-ruby(bound to C-c C-s), which can be used to start an interactive ruby session.While in a Rails project C-c M-s can be used to load script/console (irb with the project environment loaded).
• Auto-generatable snippets: YASnippet(pluskid) has this awesome snippet support which can be used to selectively load snippets for a particular mode. Snippets can be overridden by adding a custom location to pick snippets from after loading the default snippets(no need to dive into library code base to make changes)
• Ability to run multiple terminals: Not just one, there are multiple flavors of terminal supported within Emacs(ansi-term, shell and eshell to name a few). Each one has its own strong points, but they are all great.
• Ability to open directory within a buffer: dired is your friend (its a full blown file manager).
• IRC client: rcirc can be used to keep in touch with IRC channels. A line or two of lisp can be dropped in to change its default behavior(such as what channels to join, on which servers, using what alias… etc).
• Snappy frontend and sensible keystrokes: Its has lower footprint than most other editors, TextMate and RubyMine are no match. I can not say it has not frozen ever, it does(but very occasionally). Even when it is frozen, 3 Esc hits or C-g can be used to abort the activity causing it to freeze. I don’t remember killing it(have been using it for more than a few months now). It just never gets that bad.
• Straightforward key-bindings: I feel key-bindings are very carefully chosen. More common the key, closer it it to the home row index finger positions(f and j). Macro record/play is bound to C-x ( <definition> C-x ) (parenthesis make sense to developers at once, and i believe its quite intuitive a binding to define something. C-e can be used subsequently to play the macro(macros can be stored by numbers and names too). Even complicated keyboard shortcuts like kill-rectangle have sensible C-x r k (r -> rectangle, k-> kill), paste rectangle similarly is C-x r y (y -> yank). Navigation keys are C-n (n -> next), C-p (p -> previous), C-f (f -> forward), C-b (b -> backward). Sensible key bindings are much easier to remember. Orthogonality is maintained across actions C-u <x> <action> does something x number of times and works across different types of actions.
• Running single commands: M-! can be used to run commands from within emacs(output is captured in a buffer and shown to the user).

In addition to these emacs comes with some not so well-known features(which need a little exploration), for example make-frame-on-display can create frames on other hosts(making pair-programming really simple). It has terrific Mail/News/Feed reader called Gnus, a beautiful mode for organizing yourself up called Org-mode and a host of other great things like TRAMP(Transparent Remote (file) Access, Multiple Protocol) which lets you edit remote files over a whole bunch of protocols(including ssh, smb, rcp etc) and also allows editing of local files as root(using su). It can open compressed archives(and edit files in place), java jars, PDF files, images…. you name it. Combined with dired, these capabilities make it a great tool. This post has only tried to explain what Emacs is capable of with respect to other editors, and trust me, I haven’t even skimmed the surface of it. One really needs to use it to find out what a brilliant tool it is.

It can be a little daunting for a beginner to set Emacs up from scratch(it is not difficult; its just takes some time and patience). I have spent time setting it up for myself, and I think it is a good setup to start with for people doing Ruby(Rails)/JavaScript and Lisp in general. My repository is available at http://github.com/janmejay/emacs. One of my motivations to put it out is to help other developers(especially people starting out with Emacs), so feel free to pull it up and take it for a ride.

Like every other powerful tool, Emacs has bit of a learning curve, but i believe it pays off, and it pays off pretty well. To a programmer, its not just an editor, it is a “friend for life”.

pluskid