Stumble to the kitchen counter, rub the sleep out of your eyes. Kettle on the stove top. Bubble bubble. The sound of hot water hitting a layer of dry coffee grounds, swirling them around, lush caramel-colored head forming. Push the plunger down, slowly, strange satisfaction from such a simple task. A slow pour, dark black ringed with hues of translucent brown, fill the cup and watch the steam rise off the surface. First sip, chocolatey bitter savory delicious….
This isn’t about coffee
This isn’t about French press coffee. This is about pushing the details down and bringing meaning to the surface, like pushing down the plunger to bring the delicious mix of hot water and coffee grounds to the surface. I started thinking about this when I joined the development team at Gust. One of the things that was so attractive to me about the team was their devotion to process (XP/Agile) and expansive toolset (TDD, BDD, CI, Gitflow). One of those tools happened to include the team’s editor of choice, Vim. I had played with Vim a bit, but had always favored RubyMine for development, enamored with it’s refactoring shorcuts and language support.
As I fumbled around reaching for the escape key, forgetting which mode I was in, I felt like I was spending more time mastering Vim than the code I was working on! I missed RubyMine’s helpful shortcuts ( extract method, inline variable, intentions, oh! Intentions!). I started to consider how, in many ways, the IDE was so great because it abstracted away most of the tactical details of what you were doing ( editing textfiles ) and elevated the context and real ‘meaning’ of the intended final product ( a well-factored codebase ) to the forefont. I started analyzing everything I was doing in terms of ‘how much does this /tool\/class\/method/ push the details down and let meaning rise to the surface?’ And why should that matter? With the propagation of ever more development tools, frameworks, platforms, etc., I think it’s important that we take care not to get lost in the details, to not let our fascination with implementations take the focus away from the problems we’re attempting to solve.
Don’t Get Lost in the Details
I recently read ‘Confident Ruby’ by Avdi Grimm, in which the author talks about the ‘storyline’ of methods in Ruby, writing that well-factored methods ‘straightforwardly convey their intent’, without obstructing their storyline. Maybe that’s what got me thinking about surfacing meaning. Maybe it was the new French press coffee maker I got for Christmas. Some seeds might have been planted when watching this talk by Bret Victor, in which he suggests that we should do more to keep approaching our problems in new, and perhaps more ‘meaningful’, ways, rather than just perfecting the current de-facto techniques. In any case, it’s made me grateful for my current development team, that are putting as much effort into building domain knowledge and sharing high level context with the entire company as they are to perfecting their tooling and digging into implementations.
Drink it Up
I’ve become much more comfortable using Vim these past few months (check out Gust’s awesome Vim config for a sweet setup), and have come to find that Vim, in it’s own way, does quite a good job of bringing meaning to the surface. The different modes (insert, visual, command-line, normal, etc.) force you to consider what your intent is, and in what context you’re modifying the codebase (adding, refactoring, replacing, removing(joy!)). In the end, one of the greatest values in using both RubyMine and Vim, for me, has been the realization that the tools we use, along with the code we write, the applications we develop, the companies we run, are of the highest value when they abstract away the details and bring meaning to the surface. Think I’ll go put on a pot of Ethiopian Yirgacheffe and think about it some more…