Strong Feelings

While growing up, I lived in a rather small, conservative, rural community. Like many in my hometown, I subscribed to a set of views which were quite exclusive. I was encouraged to attend conferences and retreats at which leaders spoke at length upon the importance of gently teaching (rather, convincing) others of the errors of their ways with great fervor.  Upon leaving my hometown for University, I was surprised to find that there were plenty of people of different backgrounds, many of whom who held no such views at all, who were kind, generous, and seemed to get along just fine.

Today, as developers we find ourselves in a community showing symptoms of the same fatigue.  Turf wars between advocates of particular languages, frameworks, and methodologies leave us all weary and second-guessing ourselves as we re-trench to secure our preferences and prepare snide retorts to those who prefer another language, deployment stack, or DVCS.  Having written or substantially contributed to programs written in Ruby, Python, Java, Scala, PHP, Javascript, C++, and a few other languages, I feel comfortable saying this: Once you’ve worked with a handful of languages, it’s hard to have strong feelings about any of them.

Of course, it’s natural to have preferences. But as options grow, these preferences quickly become bound to particular domains.  I love Python for its concision, Ruby for its expressiveness and malleability, Java for its speed, power, and wonderfully intelligent compiler, Scala for its elegant type system and inference, PHP for its ease of deployment in nearly any environment, Javascript for its approachability and flexibility as a dynamic language with prototype-based inheritance and a rich object system, C++ for its raw performance when built by a clever compiler, and so on. When you’ve got a lot of great tools in the box, it’s harder to sneer at your options.

It pains me to see developers whom I otherwise respect professionally engaging in what amounts to pissing matches in conversation. What does it accomplish? Who is convinced of the error of their ways? Who leaves the discussion a better, happier, more productive programmer? As my brilliant bearded coworker Schmichael puts it, it is unfortunate to see programmers struggle in anger with other workmen’s tools. The “other work[wo]men’s” bit is important. Each of these languages, datastores, version control systems, web servers, what have you – are created by programmers Just Like You, and map to a world that makes sense to them and their particular problem domain. It’s natural to experience frustration when getting up to speed with unfamiliar tools. One can barely help hitting their head on sharp corners when stumbling in the dark. The point is that it’s not terribly productive to blame the house for “being in the way” while stumbling toward the sofa.

Some time ago as a Ruby developer, a project manager told me that we’d won a contract with a major global brand to develop an application with outlandish requirements – frightening enough as it was – but also that the project had to be completed in Java.  How I wretched and pleaded!  “Not Java,” I thought - “it’s so verbose!” Terrified that the next six months would be filled with FactoryFactories and ManagerDelegates, I spent a week learning the language and was surprised to find it clean, well-designed, backed by an impossibly rich array of libraries whose APIs had been stable for nearly a decade – and dare I say, almost expressive. The experience was an eye-opener for me. The project was completed on time and within budget by a small team of developers working in an unfamiliar environment. We hit our heads left and right, but learned a hell of a lot and bonded as a team along the way.

I mention this example because I found tremendous value in attempting to learn a new language - one emerging from a very different design paradigm with different use cases - than my preferred environment at the time. As my pleas met my (outstanding, hilarious, client-ass-kicking) PM’s condolences, I began to notice that what I’d previously considered warts in the language were quite empowering (in this case, static typing). Perhaps the same could be true of other languages, I thought. So I began an experiment in which I would unconditionally discard my initial negative responses when learning a new language or system in hopes that I would come to understand a fellow programmer’s reasoning behind (and appreciation for) them. Typical examples of these discarded reactions included:

• Ugh, it’s so verbose.
• It’s way too magical.
• This packaging system sucks.
• The global namespace is so crowded.
• It’s so free-form; this feels like cowboy programming.
• Luck is not a type system.

Over time, I found that my preferences evolved. Rather than bending a single language to meet my every need, it became apparent that some flexibility is essential to becoming a programmer who is able to address a variety of problems quickly, efficiently, and reliably.  Coming from a dynamic language background, I began exploring statically typed languages like Java, Scala, and C#. While type declarations may stand out as “noise” to the dynamic programmer, it became clear that these empower compilers (and well-equipped IDEs) to intelligently analyze programs in great detail, enabling them to comprehend the deep structure of the code and immediately point out problems, warnings, and suggestions.

To step back a bit, my point has little to do with static typing or the JVM. It’s that a conscious effort to learn and understand unfamiliar languages and paradigms is rewarding – and that perhaps the greatest reward is an understanding of new modes of thought and a concomitant destruction of bigotry within the development community. Call it “peace through polyglotism.” I’m not suggesting that our discussions would be better off under the watch of a thin pluralism preventing us from speaking our minds – but rather that we’re better able to make informed decisions and more equipped to appreciate each other’s languages, toolsets, techniques, and strategies as open-minded peers than when operating under the sneering, disempowering mindset of One True Language that closes our minds to new ways of thinking.

Because most people get along just fine.