Gustavo Duarte recently posted an article about the folly of dabbling in new languages.
The post is an earnest one, and thought-provoking, but I realized this evening that it is a masterpiece of logical fallacy.
Problem #1: Begging the Question
Gustavo argues that "dabbling" in new languages gives superficial results to your career. To dabble is to "work at something in a superficial manner". So, the argument is that a superficial investment in something yields superficial results. Hmmm... this seems like begging the question to me.
Note that I don't mean the popular usage of "that begs the question: yada yada" but rather the classical sense of proving something that is implicit in the premise.
Problem #2: The Strawman Argument
Gustovo condemns the Pragmatic Programmers' advice to "learn a new language every year". But he goes on to set up that advice as though they are saying "Open an editor, screw around with some syntax, and wait for the enlightment to hit you". Then he knocks that Strawman down, with ease.
I just checked the Prag Prog book: it is relatively terse on this point. I may be guilty of my own "Ironman Argument" here but, having seen Dave Thomas speak on several occasions, I doubt if they intended for us to take a full year to merely mess around with some core language syntax. My guess is that they will agree with the examples in the next item.
Problem #3: False Alternative
Gustavo seems to set up two choices: either noodle around aimlessly with a new language, or learn something specific with your current language, such as algorithms, math, or AI.
Wow. We have hit the trifecta now with the fallacy of false alternative.
There are more than two choices. Let's assume that we only know Java. How about these examples:
- Write an implementation of a Red-Black tree in Scala.
- Compute Pi to a million decimal places in jRuby. Then check an online source to see if you are right.
- Develop a simulator for Tic-Tac-Toe that uses genetic algorithms to evolve a winning strategy. Use Groovy.
Problem #4: When timeless arguments aren't timeless
This isn't a formal logical fallacy, but Gustavo hints at some classic, timeless elements such as Lisp and the "Gotos Considered Harmful" article.
One might think that his arguments are timeless: nope. He asserts that:
In reality learning a new language is a gritty business in which most of the effort is spent on low-value tasks with poor return on time invested. You need to get to know the libraries, struggle with the environment, find or tune a text editor, look for tools, and so on.
This was true in the past, but with languages on the JVM and the CLR, we are in a golden age. As proof, consider the 3 examples above: all of those languages are a simple drop of a jar file and allow the use of the Java libraries. They run on the JVM. (Ted Neward has given entire keynotes on this idea.)
I will grant that the debugging/IDE facilities won't match Java, but this argument is completely bogus.
Problem #5: Confusing Momentum with Inertia
Again, this isn't a fallacy per se, but I take issue with this:
There’s another pernicious effect to language hopping: it hurts your momentum. Every time you rely on your current languages you get a little better.
Last year, I blogged about using Groovy to interrogate an OODB. My team still uses that tool. Anyone on the team could have written it in Java, but in the span of 5 years, no one had done so.
That's not momentum. That, my friends, is inertia. My little Groovy program is one of the biggest contributions I've made to that team: people ask me for it all the time.
Gustavo ends by recommending that we learn languages that are orthogonal to each other. I agree completely. And, for the record, I agree that merely dabbling is dangerous: I have probably been guilty of it myself.
But I heartily recommend learning a new language. And learning as much as you can about logical fallacies. They are everywhere (in this post?).