El Tramo

My Favorite Vim Plugins

2013-05-17T22:00:00Z

After a brief affair with another editor, I’m now back to using my beloved Vim again. What’s more, I decided to invest the time I should have put in years ago when I started using it, and learned to do things more efficiently. Besides reading Practical Vim and watching some VimCasts, I went through my list of plugins I collected over the years, removed the ones I wasn’t using, learned about a couple of new ones I didn’t know, and re-learned some of the ones I forgot about. Here’s the list of my favorite plugins I ended up with.

pathogen: Easy management of Vim plugins. I put all my Vim settings in a Git repository, and this plugin allows me to add plugins as a Git submodule somewhere in my settings tree. For an extensive tutorial, have a look at the pathogen VimCast. Several other plugin managers (such as VAM and Vundle) have emerged since I started using pathogen, but I haven’t tried them since this one does the trick for me.
sensible: Have sensible, safe defaults for a modern day Vim setup. Allows me to trim down my vimrc a bit.
ctrlp: Open files anywhere below your current directory very quickly, using fuzzy search. This is similar to Sublime’s “Go to anything” (which even uses the same shortcut). I almost exclusively open files using ctrlp.
unimpaired: Easy to remember extra ] and [ shortcuts for a handful of useful tasks: cycling through files, buffers, arguments, SCM conflict markers, spelling errors; exchange lines, switch options, insert empty lines, … Also comes with shortcuts to toggle options, such as col (toggle invisible characters), con (toggle number column), cos (toggle spell correction), …
detectindent: Automatically detects whether tabs are expanded or not. Handy for working on multiple codebases with different tab preferences.
a: Switch between corresponding .h and .(c|cpp|mm) headers easily
ack: Lightning fast greps across a project. I actually use ag as backend.
clang_complete: C/C++ code completion that works. Requires clang to be on your system (which it is by default on MacOS X)
endwise: Automatically adds end when you write a begin, but does it conservatively so it never inserts anything unwanted.
fugitive. An extremely powerful Git integration for Vim. Apart from providing an interface for doing all kinds of (interactive) Git tasks from within Vim, also provides a status line entry for showing your current branch etc. There are a couple of VimCast episodes about how to use this plugin.
abolish: A set of search/replace/conversion commands that support plurals, case (MixedCase, camelCase, snake_case, …), … Can be used to rename variables easily, change case of avariable, … There are also some VimCasts about this plugin.
gundo: Graphical overview of Vim’s undo tree. If you undid a couple of changes, did some other stuff, and decided that your initial version was actually better, you can easily revert back. This has saved me and my undecisive mind a couple of times already. Also has a VimCast.
matchit: Match more than just braces with %. Cycles through if/else, matches HTML/XML tags, …
surround: change/delete/add surrounding quotes, parentheses, tags, …
syntastic: Checks the syntax of your current file on save, and displays errors using markers in the sidebar. Saves you a round trip to your terminal when trying to compile/run the file.
taglist: A navigation window with an overview of all functions/variables in your current file. Uses ctags behind the screens, but doesn’t require you to run ctags yourself on the codebase. It can also put an entry with the current function in your status bar (which is useful when editing files with large functions).
tcomment: Quickly comment out lines and code blocks. I used NERDCommenter for a while, but tcomment came with more natural Vim shortcuts (and is also supported by Vrapper). I also tried commentary (mostly because it’s by Tim Pope, and because it supports repeat), which uses the same shortcuts, but this one doesn’t comment indented code blocks the way I want it to (i.e. put the indentation after the comment string instead of in front).
easymotion: Makes it easy to jump to any word in your buffer, by assigning a single letter to each word, highlighting it, and drilling down with each keystroke. Although this plugin is probably as fast and intuitive as it gets, in a GUI mode, it may be a tad faster to simply reach for the mouse and click in the document. However, when editing remote files without mouse support, this plugin is great!
snipmate: An engine for inserting snippets of code. There’s also a standard repository of standard snippets, but I mostly only use my own snippets for larger snippets (e.g. create a new class, insert copyright headers, …). Downsides: it no longer works with clang_complete (although it used to), and it seems hard to override already existing snippets (which is why I don’t use the default repository).
mru: Easily access recently opened files through the MRU list.
dispatch: Asynchronous version of :make, so you can still edit your code while your project is building. The downside is that it requires iTerm on MacOS X or fires off a separate command shell on Linux and Windows, so it’s still not as nice as a native window running a build in its own thread, but it gets the job done.
NERDtree: A better file system explorer than the default one. I don’t really use it that often (since I use ctrlp to open files), but it’s handy for when you need to look around your project tree.
repeat: ‘.’ support for some of the plugins I use.
speeddating: Increment dates using Ctrl-A/Ctrl-X. Not that I often do this, but since it just adds extra support to Ctrl-A/Ctrl-X, I just load it.
molokai: A beautiful dark gray color scheme, based on the Monokai scheme from TextMate, and popular in other modern editors as well.
Vrapper: Not really a Vim plugin, but worth the mention: this Eclipse plugin provides a wide variety of Vim bindings to use inside Eclipse, so you can stay efficient when working on Java/Eclipse projects.

The Sublime Text Experiment

2013-04-29T22:00:00Z

I’m not easily persuaded to try out a new editor, but since I heard so many great things about Sublime Text, I decided to give it a try. After all, it looked a lot better and smoother than my old and rusty Vim, and I’m a sucker for look & feel. So, I took the free courses on tuts+, and tried it out for a while on my daily tasks. Here are my findings.

Let’s start with the pros:

Sublime is cross-platform. I wouldn’t even consider using any editor that only works on one platform, so this one was a must.
Not only does Sublime work on each platform, it looks and feels awesome on all of them. Very smooth, responsive, and appealing to the eye.
One of the distinctive features is support for multiple cursors: You can make the same change to different parts of the text by simply selecting different parts, and starting to type, and you see the changes happening live. This is very handy for refactoring, such as renaming a variable.
The command palette makes it very easy to do any operation you can’t be bothered to remember the shortcut for. Simply open the command palette, type a few letters, and Sublime will use fuzzy searching to suggest the command/option. Almost as good as remembering a shortuct.
Every operation and option is available from the intuitively laid out menu. Not that you use the menu a lot (or even at all, thanks to the command palette), but it’s great for looking around and learning all the things you can do with the editor.
You can quickly open files and jump to specific symbols using the Go to anything popup. I was already using this exclusively to open files on Vim through ctrlp, but Sublime adds support for symbols and lines to this interface as well, which can come in handy.
You can trigger builds of your project while editing files, see the results, and quickly cycle through build errors. This integration is very well done, much smoother than in Vim for example.
You can use Vim commands to move around and edit text, which is obviously nice if you’re used to those already, and means you can do lightning fast edits.
Of course, there are lots of useful operations on text, with sensible keybindings
Sublime is extensible, using a Python-based plugin system. There seems to be a very large and dedicated community, writing plugins for it, which means you’ll most certainly find all the integrations and features you want on the web.

Unfortunately, there are also some cons:

Although Sublime is cross-platform, it seems to not have been designed for the user who actually uses it on different platforms. For example, the key-bindings differ from platform to platform, more than merely Cmd becoming Ctrl. This is probably rooted in Sublime’s decision to use shortcuts that are native to the platform. Remembering different shortcuts for different platforms is a nuisance, and causes regular incorrectly typed shortcuts when switching a lot.
Settings are stored in fixed, platform-specific locations. Again, this is because Sublime chose to integrate with the OS as much as possible. However, this makes it hard to store your settings in a central Git repository, and share it across different machines and OSes.
Sublime uses JSON as settings format. Although that sounds sensible, it actually has a big disadvantage: each line of your settings needs to end with a comma, except for the last line. This hit me almost every time I wanted to customize something. Another consequence of using JSON is that the settings file isn’t very powerful: since it’s basically just key/value pairs, you can’t do anything conditional (e.g. depending on which machine you are on), or source other files.
There is no console version available. I regularly need to edit files on remote systems where I only have a terminal available. In that case, I need to switch back to another editor.
And then the obvious one: Sublime is closed source, and not cheap. I don’t have anything against closed software per se, and I’d gladly pay the (relatively steep) price of the editor if I’m going to use it all day, every day. However, I have some practical problems: the systems I work on every day can’t run Sublime, since it is linked against older libraries than the ones I have available. Since I can’t recompile Sublime myself to link against the older libraries, it ends there. And then there’s the fact that I don’t like the idea of my editor’s life depending on one person’s focus and ability to avoid being hit by a bus. If the project dies, maybe someone will create a clone to support the current userbase, but I still consider it a risk.

I only tried Sublime Text 2, but since these issues are pretty fundamental, I don’t think they will have been addressed in the upcoming version. Since I had an uneasy feeling about these things, and was regularly hitting the issues over and over again, I finally decided to go back to Vim. However, I think Sublime Text is a great editor, and is probably the closest an editor will ever get to being a Vim alternative I find worth considering.

Book Review: Wonderful Life with the Elements (Bunpei Yorifuji)

2013-02-27T23:00:00Z

In Wonderful Life with the Elements, the Japanese author (and artist) Bunpei Yorifuji takes you through all the chemical elements in a playful, entertaining, and very graphical way.

By representing each element as a cartoon character, mapping chemical features (such as atomic weight, state, special properties, …) onto human properties (body weight, hairstyle, clothes, …), and drawing the resulting characters in different (often humorous) situations, he illustrates the properties of each element, their history, and their use in every day life. Besides a detailed graphical description of each of the elements, the author also describes properties about the elements in general, discusses classifications, gives background on the periodic table, and puts everything into context.

The drawings (which make up most of this book) are original, funny, and very nicely done. Small things like the Japanese name and Chinese character for each element give it a nice aesthetic touch, but are of course completely useless for an ignorant westerner like me. I learned quite a few interesting facts about chemical elements, things I either forgot, or never knew at all. It feels like the cartoons and the element “personifications” should make these things stick, but I can’t say whether they will after just one read. Then again, if not, at least it will have been a very entertaining read, and I’ll be happy to read it again as a refresher.

My only (very minor) remarks are about the format. The PDF in which the eBook comes seems to be too tough to handle for some viewers: Preview.app choked on it and was missing graphics, but Acrobat Reader (and some built-in browser PDF viewers) seemed to display all graphics fine. Although the overall detail of the graphics throughout the book is good enough, the centerfold page (containing all the elements in the book in on one big poster, at least in the dead-tree version) is lacking in detail, and becomes ugly when you start zooming into the separate elements to the level you need to. This isn’t really a blocker though, since all elements are displayed on a full page illustration later, but it would have been nice to have more detail there (or have vector-based graphics throughout the whole book). And finally, the book isn’t hyperlinked at all, so you can’t navigate easily from e.g. the index or the table of contents to the corresponding pages in the book.

In summary, I really liked this book, and would recommend it to anyone wanting to learn (or refresh their knowledge) about the elements in a light and entertaining way.

From WordPress to Nanoc

2013-02-22T23:00:00Z

After 7 years of serving my blog/website with WordPress, I thought it was time to try something else. One of my biggest gripes about WordPress (apart from having to hold my breath on each version update) is that writing posts through a web UI isn’t very handy: it’s slow, inconvenient for complicated posts (especially if you’re used to your favorite editor), you can’t write while offline, and the versioning is limited (compared to real versioning systems). So, I decided to give static blog generators a try, and ended up converting my blog to Nanoc (after a brief stopover at Jekyll). Result: I can now write my posts in VIM, use Markdown syntax for writing, preview my posts live using tools such as Marked and MarkdownPad, preview the site using Nanoc’s built-in HTTP server, easily customize my site with some Ruby code, and keep everything versioned with Git. And of course move it on Amazon S3 in case my blog really hits off and starts getting million hits a minute (which should be any day now).

In case you’re interested in the details of how I converted from WordPress to Nanoc (including code), read on.

Before settling on Nanoc, I first gave Jekyll a try. However, Jekyll always had a very ad-hoc feel to it, with filled with decisions that didn’t always work for me, and lots of untransparent magic going on behind the screen, which also didn’t always work for me. Nanoc is a lot cleaner, powerful, more extensible, and easier to understand what’s going on. Luckily, the post format of Jekyll is compatible with Nanoc, so the steps for migrating directly from WordPress to Nanoc should be the same.

Here’s roughly what I did:

First of all, I got the posts out of the WordPress database using Vito Botta’s WordPress-to-Jekyll script (with some minor changes). This script pulls out the posts as HTML, with metadata prepended as YAML front matter (which is what both Jekyll and Nanoc use). (See an Example Post)
Although WordPress posts use HTML for markup, the markup omits <p> paragraph tags (as they are added automatically for empty lines), which means rendering them as HTML doesn’t look as it’s supposed to. Fortunately, if you treat the HTML files as Markdown (and use RDiscount as your posts filter), the result ends up as expected: the HTML markup is preserved, but paragraphs have been added in the right places.
For the layout, I just reused the Twenty Ten theme I was using before. WordPress does a good job at separating presentation and structure, so I just mimicked the <div> structure in my layout files, copied the CSS files unaltered.
One thing you can’t do with a static blog is serve comments, so I moved the comments to Disqus. Before getting rid of WordPress, I installed the Disqus Plugin to do a one-time import of all comments. Using the WordPress ID and URL (pulled by the script mentioned earlier, and put in the YAML front matter of the converted posts), you can reconstruct the right ID for keeping your comments intact on the new site. (See the Disqus Template)
In order for the front page to show excerpts instead of full posts, I use a filter (and a helper) to strip everything up to the  tag, put this into a separate nanoc representation, which in turn is used when populating the paginated blog pages.
For the tags and categories, I use another helper to generate the list of categories and tags for each post, and to generate a page for each category/tag containing all the posts for that tag (and their RSS feeds)

That’s it for the basic functionality. Then, there’s some sugar coating and extra stuff, such as:

A tag cloud in the sidebar, using a helper.
Support for Twitter cards. I added a rule to make a ‘filtered_contents’ snapshot after applying the Markdown filter, and use this snapshot in the ‘head’ section of the layout, as you can see in this template.
Embedded my Git repositories using CGit, by splitting up a rendered dummy page (again using a simple filter), and using these resulting pages as header/footer for CGit. It doesn’t look perfect yet though (diffs are too wide for the layout for example).
Since the CGit integration isn’t perfect yet, I added a filter to rewrite all internal Git urls to point to my GitHub repositories. If I decide to switch back to my own (or another) public Git interface, I won’t need to touch my posts.
Embedding image galleries using Galleriffic (although I dropped my galleries recently)
An update_software task for auto-generating all my Software project pages from the README files in the project Git repositories.

For the nitty gritty details, you can have a look at the code (and some example content) in my Git repository.

Swift 2.0 Released

2012-12-30T23:00:00Z

Just in time for a 2012 release: Swift 2.0 is out! This new stable release has many enhancements and bugfixes, so head over to the Release Notes page to find out what’s new.

Happy New Year!

Swift 2.0 Release Candidate Released

2012-11-15T23:00:00Z

That’s right, we’re almost there: we just put up the release candidate of Swift 2.0. If no critical bugs are reported, this will become the final release. As always, we encourage everyone to get the new build and try it out, and tell us about any bugs they should come across.

Swift 2.0-beta2 Released

2012-10-07T22:00:00Z

We have just released the second (and final) Swift 2.0 beta. Apart from several bugfixes, highlights include the possibility to set custom connection options, getting detailed information about certificates upon connection errors, and improved room invitations. We encourage everyone to get the new build and try it out, and tell us about any bugs they should come across.

Swift Hackathon Roundup

2012-05-05T22:00:00Z

Last sunday, we finished our week-long Swift Hackathon, and it was a great success, leading to Swift 2.0-beta1! Here’s a list of the things we achieved during that week.

First of all, the goal of the week was to find and fix as many bugs as possible. This is what our ‘hackathon bug count dials’ were displaying at the end of the week:

In only one week, we found 19 bugs, and fixed 64! Not a bad result for our first hackathon, don’t you think? As you can see from the trend, we put a big dent in the list of open bugs:

And if fixing all these bugs wasn’t enough, we found the time to do some other things on the side as well during the week:

Together with Olly Betts, we finished our Debian packages, and submitted them to Debian. So, expect both Swift and Swiften to be available from the official Debian repositories soon!
We set up a build for the brand new Ubuntu 12.04 (Precise Pangolin)
We started fixing and cleaning up translation strings

Thanks again to all the people who have helped us during this excellent week!

Swift 2.0-beta1 Released

2012-05-03T22:00:00Z

After another year of development, we’re happy to announce that we released our first Swift 2.0 beta! We encourage everyone who is interested in helping us with testing to try out this new release, as it has many bugfixes and enhancements (see the release notes for more details).

Thanks to the hackathon week (of which details will be posted shortly), we believe this first beta to be pretty stable. Nevertheless, should you find some bugs, please come and tell us about it!

Steve Jobs would not appr o ve

2012-04-30T22:00:00Z

In his famous 2005 Stanford Commencement Speech, Steve Jobs explained how his interest in typography played a fundamental role in creating the first Macintosh computer, and how the beautiful typography set the Mac apart from other personal computers out there. He was obviously passionate about these things, going as far as pixel-perfectionism about fonts and icons. That’s why I was a bit shocked when I started noticing bad kerning (aka keming) in the iOS 5 status bar. Could it be that these are the first artifacts of the post-Steve Jobs World? (Update: No)

Spoiler alert: As XKCD points out, recognizing bad kerning is something you may not want to learn about. If you like your iOS status bar, consider not reading on.

Have a look at the battery level indicator of the iOS screenshot below:

Now compare that 44 with the one from the clock. Doesn’t look right, does it? How about something a bit more obvious: charge your iDevice to 100%, and you see the following:

That 1 in the battery level almost looks like it’s coming from a different font?! Still not convinced? How about anything in the 10-19% range?

You have to admit that this is much worse than pixel-imperfectionisms. Even if this was post-Steve, or Steve always had his battery level indicator turned off, you would have come to expect someone at Apple must be annoyed by this, surely?

I know I’m nitpicking, but the problem is that, if you noticed it once, you will notice it every time you look at your status bar. The only solution: disable the battery level indicator.