If you use Vim only to edit text files when you happen to be logged into a CLI: mosey on along, this isn’t the book for you. If you currently use Vim regularly and want to improve your knowledge and effectiveness with it: your time reading this book will be well-spent. If you’ve somehow never heard of Vim but are enraptured by the idea of a text editor that can be an effective IDE in addition to allowing you to play Tetris and Rubik’s Cube: you might like this book too.

At first this book seemed rather short for such a potentially expansive topic. In the end I found this to be mostly a virtue rather than a problem, as the amount of information presented is, in fact, voluminous. A more comprehensive approach likely would have been too hefty and less effective. It doesn’t pretend to be a manual for Vim. Instead it illustrates the best approaches for various issues and situations, suggests improvements on more common operations, and provides lots of references to external resources (primarily Vim internal help and vim.org) to learn more. Examples and illustrations provide insight into some of Vim’s lesser known abilities, while commonly used ones are explained and presented in new and useful ways. Groups of features resolve into solutions.

Chapter by Chapter

Chapter 1, Getting Started with Vim

Primarily a history of the Vim editor. Useful to expand the knowledge of Vim fans, but not really pertinent to hacking your beloved editor. Would probably have been better as an appendix or excised entirely.

Chapter 2, Personalizing Vim

Editing your Vim config, customizing fonts, colors, menu buttons and other UI elements. Lots of great material for tuning the visual appearance. More about vim.org and other resources for colorschemes (such as this gem) would have been helpful. The ability to add tooltip balloons was new to me and quite exciting. Schulz provides a number of great examples for their use. The discussion of abbreviations was a bit confusing, especially considering the recommendation of the more intuitive snippets approach in Chapter 4.

Chapter 3, Better Navigation

By now you might already be feeling overwhelmed by the number of key commands to remember. I recommend starting a cheat sheet of those you find especially interesting. Speaking of that, perhaps it’s just my predilections and lack of a perfect memory, but the vast number of code navigation keys was just a bit too much. Sure, “extra keys pressed equals extra time wasted”, but what about extra time sorting through key commands in your thoughts? Still, plenty of tips should be mind-blowing if new to you. Jumping to files named in the text of the current file, for example, is really handy. The information about search improvements, both in user files and in the help system, was quite good. I’ve yet to really use signs or marks, but found their explanation here illuminating.

Chapter 4, Production (Productivity?) Boosters

Templates! Templates are awesome, and this was a welcome introduction to a topic I’ve barely scratched in my Vim journey. I’ve also not used placeholders in templates before, which look to be quite useful. Tag lists and essential plugins for their use are explained, providing an effective presentation of this feature. I was getting a little worried around pg. 86, as the number of Ctrl + x, Ctrl + SOME_KEY commands started to get cumbersome. Then came the explanation of triggering all completion types using a single key, which was quite refreshing. Complete using dictionaries, words in the current document, language files, and more, all using a single key. The SuperCleverTab function will be a very welcome addition to my configuration. Until seeing the example about macros, I never really felt how useful they might be. This definitely convinced me.

But this meaty chapter isn’t over yet! Sessions felt rather opaque to me before reading this section, and I think they will now definitely serve a role for me. No more ritual of opening the right files, folding them just how I want, etc every morning. Undo branching… I still find this rather too complicated and marginal of a feature to care about. But the examples were at least explanatory. Folding is a great eye-saver, and the coverage was adequate. I’m still not really a fan of vimdiff, as there are other diff utilities out there that make the process faster and more intuitive to me. One exception is finding the diff between the current buffer and the saved file, which is very handy and not something available in most editors for sure! I hadn’t opened remote files in Vim directly before, so the section on this at the end of this chapter was quite useful.

Chapter 5, Advanced Formatting

I felt mostly ambivalent about the beginning of this chapter. To me, if you want text aligned a certain way, or want to create proper lists and use other more advanced document formatting features, you should use a word processor. Adding whitespace to my text files for alignment’s sake doesn’t strike me as a good idea.

The second part covering formatting pertinent to coding was much more useful. I’ve used things like autoindent and formatting of pasted code for a while now, and they are quite essential to sanity. Great coverage for those new to these features. Integration of external formatting tools such as Tidy is also described.

Chapter 6, Basic Vim Scripting

“Now we get to it” was my feeling starting this chapter. There’s some very helpful stuff in here, but it’s strangely organized and should have been moved or at least mentioned earlier in the book to provide the most benefit. Some critically handy items: explanation of Vim configuration file directories, how to properly override layers of configuration, Vimball installation, syntax highlighting and colorscheme creation. Then… comes an introductory language tutorial. Honestly, it’s pretty dull and mostly elementary. I would have rather this been moved to an appendix mentioned early in the book. It does provide broad coverage of the basics one would need to start writing Vim scripts.

Chapter 7, Extended Vim Scripting

Everything you need to know about actually writing Vim scripts: suggested code format, function structure, adding key mappings, detecting OS and Vim version, debugging and distributing scripts, documentation, even integrating programming languages like Python and Ruby! This is certainly a great reference to get started with Vim scripting. Schulz also gives an example script wrapping up a number of these points, providing something like a Vim scripter’s “Hello World”.

Appendix A, Vim Can Do Everything

Examples of the many and varied things you can do with Vim, such as Tweet and play Tetris. Provides amusement, but not a lot of value. The section on Vim as an IDE should really have been expanded to an entire chapter or appendix considering the likely audience for this book.

Appendix B, Vim Configuration Alternatives

A number of tips on how to keep your Vim configuration organized. Spends time explaining a system of scripts created by Jos van RisWick that allows the user to make changes to their configuration from GUI menus and make them permanent, instead of editing config files. I had never heard of this and found it quite interesting.

The last few pages deal with storing your Vim configuration online. While I whole-heartedly agree with the intent, the particular manifestation presented is rather terrible. Using this setup, the user’s .vimrc would be downloaded every time Vim is opened. Then it still has to be parsed, which for heavily customized setups can already take a moment. Not the best when you’re looking for a lean editor. And what about the legion of scripts and other supporting files outside .vimrc? I think not. My approach to the problem is to keep all of my Vim configuration files inside an SCM system, checking it out on each system the first time I want to use Vim.

Issues

• Confused structure: Chapters 6 and 7 felt rather strangely divided in themselves, and I felt most of the content should have been provided earlier. Having a better knowledge of the syntax and nature of ex commands/Vim scripting would have made the content throughout the book more understandable. I felt I was mostly taking the syntax in the code provided for granted, without feeling comfortable enough about all the components that I could have written something of my own design.
• Typos: The text would have greatly benefited from another round of copy-editing. Most of the errors weren’t very distracting. There were, however, a number of typos in the code provided that were more problematic, especially for a work on an editor that can be rather picky about commands. For a first edition, these aren’t overly numerous.
• Lack of color diagrams: I’m all for using black and white images when they will suffice, but when providing illustrations of *color* highlighting files, images without color are downright useless! I was rather surprised at this oversight, first appearing in chapter 2, then in multiple places in chapter 6. They could have at least linked to color images online.

Conclusion

All in all this was a very useful treasure trove of tips. Some I’ve already added to my repertoire, and more I’m trying to understand better. In fact, I learned so much from it that I decided I will likely need to drop most of my current Vim config and remake it cleanly. I know I’m not alone in collecting bits and pieces of configuration for this wonderful editor, in a fashion occasionally reminiscent of a deranged hermit crab. Now that I have a more solid understanding I can rebuild it quickly and effectively.

In summary, I agree with Brian Carper:

The best you can hope for in a book is a broad outline to point the way toward features that you didn’t know much about. Hacking Vim 7.2 achieves this goal.

Now on top of his suggestions I have one more refinement to add. I’ve defined a snippet in vim for whenever I need to use the debugger. You should be able to define the same in whatever editor you use (and if your editor can’t do snippets, get a real one). When in an .rb file, “debug” + Tab becomes:

In addition to the format Trevor suggested (which calls the necessary module, turns on auto evaluation, and calls the debugger itself) this adds a simple assignment after the debugger is called. I often find this necessary because I want to debug right at the very end of a given suite, a conditional, a method, etc. But if you invoke the debugger as the last statement in such a situation, it won’t actually be called. Here’s an example file:

When you run this, you won’t get a debugger console. All the output you get is “Entering troubled function…” and the script exits. If instead you add the assignment I list above after debugger is called, you will get to the debugger console. Sad, but true. (You can select a less offensive assignment if you wish. I settled on it in disgust.)

Aside from this, the Ruby debugger is a useful and beautiful thing. So add the snippet and forget about it.

Commenter Vorian helpfully mentioned that the same effect can be achieved through an .irbrc file. This file can then be placed in a VCS, and in addition having the configuration in one spot is preferable. While seeking information on the configuration options available, I came across a number of additional customizations that have proved quite useful. I took this page’s suggestions mostly verbatim in formulating mine. This page was also helpful. Here’s my current .irbrc, highlights to follow:

You’ll need to install the following gems (“sudo gem install FOO”): map_by_method, what_methods, duration, and wirble. Most options should be self-explanatory and there’s plenty of commentary.

With this in place, you’ll get tab completion to assist in remembering method names and automatic indentation to make visualizing your code’s structure simpler. Output will be colorized for quicker understanding. Your activity will be recorded for later review, and when you exit you’ll find out how long you were in the session.

The two methods defined are helpers for benchmarking and viewing the methods on an object that are more interesting:

For more information on irb use, check out this section in Programming Ruby.

Tab completion

It lacks tab completion by default. Having this available can save you a lot of time, especially as you are learning the language. To turn it on, simply add the option “-r irb/completion” to require that functionality. You can also add it to a running session by entering “require ‘irb/completion’”. After setting this you can press Tab after a dot following an object to see what methods are available for it (not all methods shown in image):

Now you can type the method you want to use from the list. You can also type part of a method name and press Tab to view matches on what you have so far.

Appearance

The default prompt can also be a little too wordy:

This shows the program name (always “irb(main)” for the irb command), the line number within said program, and the indentation level. This last value is incremented as you move into loops and other multi-line structures. If you don’t want this meta information, however, just call irb with the “–simple prompt” option:

Aliases

I combine the above customizations into two Bash aliases for simpler access. Just add the following to your ~/.bashrc:

Now you can get to a simpler prompt for quick checks, or the full prompt for more complete documentation, making a tutorial, etc. And both have the lovely tab completion.

[EDIT, 2009-07-17]: As helpfully pointed out by commenter Vorian, the improvements above can also be attained using configuration options placed into ~/.irbrc. After hearing about this, I looked around for example .irbrc files and put together a decent one. Check out this post for more details.

First install Ruby and a few related items:

RDoc allows you to generate HTML API presentations from Ruby code. irb is the interactive Ruby prompt, great for trying out quick ideas.

Next you need to install RubyGems. RubyGems is the Ruby packaging system, as easy_install is to Python and apt-get is to Ubuntu. It’s a lovely package handling system. While I use and love setup_tools, it does have its shortcomings. RubyGems actually allows you to uninstall packages! Sounds simple enough, but easy_install users know this is a continual pain. RubyGems also allows much better searching and provides more information about potential packages.

I don’t recommend installing this from the Ubuntu repos. I ran into some odd problems, while the latest from RubyForge worked fine. If you do get it from the repo, be sure to install “rubygems”, not “gem” (Graphics Environment for Multimedia – PureData library)! To install from source, get the latest stable version from here on RubyForge, then:

That last step is needed since the setup script doesn’t make its own symlink. This can make for wretched confusion… Here are some basic RubyGems commands and example output:

Consider adding a few Bash aliases for faster access to the basic commands:

Next install Rails and its merry band:

This will install Rails, its library dependencies, rake, etc. I first installed Rails via apt-get, but ran into a small issue.

Next, to get the general sense of creating a Rails app, I recommend starting off with The Original Ruby on Rails Screencasts by Sam Stephenson and David Hansson on ShowMeDo. These are by no means comprehensive guides, but they illustrate doing some basic things with Rails, and end up with some pretty nice apps in a few minutes. You’ll be hard pressed to follow along yourself, depending on how many hours of Doom you played as a child.

To really start to grasp things, check out the Getting Started guide on the RailsGuides site. This goes through each step from nothing to a working Rails app. As you proceed, you might want additional information on various technical details. Look no further than the Rails Searchable API site. You can browse this online or download it locally. It provides a decent looking (finally for an HTML API: readable) and useable API reference for Rails. The search is amazing, and they’ve done a great job compressing a lot of information into a relatively small amount of space.

Once you begin looking for information on how to accomplish various discrete tasks, check out Railscasts. These assume some Rails knowledge, but are decent simple guides to how to add features like reliable authentication, avoiding SQL injection, generating PDFs, and a lot more (160 so far!).

I hope to post more on Ruby and Ruby on Rails as I learn and play around with them. If you are new to Ruby, check out this page. I came across it after I started going through a few tutorials, and find it amply summarizes most of the features I started to love at first blush.