For more awesomeness, check out my dotfiles repo called YADR (Yet Another Dotfiles Repo), featuring 100% clean vimrc with all custom keymapping done in well factored scripts inside vim/plugin/settings, and a list of plugins perfectly tailored for Rails development, currently in alpha preview.

Using vim is like talking to your editor in ‘verb modifier object’ sentences, turned into acronyms

• learn some verbs: v (visual), c (change), d (delete), y (yank/copy). these are the most important. there are others
• learn some modifiers: i (inside), a (around), t (till..finds a character), f (find..like till except including the char), / (search..find a string/regex)
• learn some text objects: w (word), s (sentence) p (paragraph) b (block/parentheses), t (tag, works for html/xml) there are others

To move efficiently in vim, don’t try to do anything by pressing keys many times, instead speak to the editor in sentences

• delete the current word: diw (delete inside word)
• change current sentence: cis (change inside sentence)
• change a string inside quotes: ci” (change inside quote)
• change until next occurrence of ‘foo’: c/foo (change search foo)
• change everything from here to the letter X: ctX
• visually select this paragraph: vap (visual around paragraph)

If you understand the verbs and objects you’re dealing with, you will soon realize that adding a new plugin and learning a new verb or noun exponentially increases your productivity, as you can now apply it in all the sentences you already know. It’s just like learning a language.

Let’s add some new text object plugins!

• install surround.vim: vim-surround- you get a new noun, the ‘surround’ (s or S)
  • visually select a word and surround it with quotes: viwS”
  • change surround from single quote to double quote: cs’”
• install vim-textobj-rubyblock – you get a new noun, the ‘ruby block’ (r)
  • delete current ruby block: dir (delete inside ruby block)
  • visually select a ruby function: var (visual around ruby block)
  • visually select the innards of a function: vir (visual inside ruby block)
• install tComment – new verb: “gc” (go comment)
• comment the current ruby method: gcar (go comment around ruby)

Now go out and learn a new verb or noun every day!

Resources and Further Reading

• Vim Text Objects, Definitive Guide, a great blog post!
• Want an exceptionally curated collection of the best plugins vim has to offer? Check out an early beta preview of my fully modularized vim/dotfile setup called YADR (Yet Another Dotfile Repo) which includes text object plugins for ruby blocks(r), indents(i), dates(da/df), function arguments(a), and ruby symbols(:)

These commands are not only extremely useful but also mnemonic and easy to learn for a huge payoff in keystroke savings. These are the common compound commands I use every day, and I think it’s easier to dive in this way than to try to learn vim key by key.

Now we’re mashing up web applications themselves, creating more and more complex applications by building on top of existing APIs. As the register was to assembler, the array to C, and the object to Smalltalk/Java/Ruby, the web API is now a building block of the platform called the Internet. So what will the next high level language look like? We will no longer concern ourselves with objects, but rather services. Standardization–whether in the form of microformats and loosely defined service ontologies or the true semantic web with all its rdf madness–will bring power to this platform.

The code we write tomorrow will create web applications and new services with just a few lines of code which integrate services from all over the web. We’ll be able to register event callbacks not just across our local objects, but across web services themselves. Call it Web Oriented Programming.

Here’s a little implementation of a Facebook driven buddy-beacon type of system in this fantasy language.

at_url("/map_my_friends") do
  @map = Google.render_map(:center => 'Chicago, IL') do |map|
    map.add_data(:source => Facebook.get_friends.locations)
    map.add_data(:source => Yelp.my_favorite_places)
    map.add_data(:source => Planypus.my_plans)
  end

  Facebook.on_update(:attribute => :location) |user|
    @map.alert("#{user.login} has changed his location")
    @map.show_at_coordinates(user, user.location)
  end
end

This isn’t too far from what’s possible today, and most of today’s ugly implementation details deal with glue code and translation between the languages of different services. The development of a standardized ontology will get us a long way toward having one-liner service integration.

Now…let’s make it happen.