Why Ruby?

[Bruno Medeiros]

On 11/12/2010 01:26, Ary Borenszweig wrote:
> http://vimeo.com/17420638
>
> A very interesting talk.
>

Whoa.

Over the last 5 years or so, with surge in popularity of dynamic 
languages like Ruby, Python, etc., I've seen several arguments put forth 
in favor of dynamic typing, and gradually I've always found there was a 
/subtle/ parallel with the arguments and reasons put forth for 
libertarian/anti-authoritarian/anti-corporate ideologies.
After seeing this talk, I guess it's not so subtle after all... ~_~'


Let me offer my thoughts on this. I don't think his argument is 
fundamentally rational. And I don't just mean wrong or illogical, I mean 
/irrational/: it is driven by an emotional bias of something not related 
to programmer productivity, which is what the discussion should be 
about. And I think his opinion is somewhat generally representative of 
many dynamic language proponents.

What I think is happening is this: These people, if and when they 
program on languages with static typing, they get annoyed by some (or 
all) of the aspects of static typing. That's normal so far, but now the 
problem is that while some of this annoyance may be driven from a 
genuine questioning of whether static typing is worth it or not (in 
usefulness and productivity), the rest of the annoyance is instead 
driven by an external emotional factor: if the language doesn't let you 
do something that it could easily let you do, then it is perceived as a 
"restriction of your freedoms". The programmer makes an emotional 
connection to personal issues unrelated to the field of programming. 
Another variant of this emotional response in this situation, and 
probably a much more common one, is not about political ideology, but 
rather the programmer perceives the language restriction to be part of a 
corporate culture that says that programmers are not smart enough to be 
fully trusted, and they need to be controlled to make sure they don't do 
stupid things. In other words the language thinks your are a dumb monkey 
who needs to be kept in line. Java is the poster child for this 
mentality, not only due to the language itself which is perceived to be 
simplistic, but also due to Java's strong association to the corporate 
and enterprise world. In a less extreme view, it is not about 
controlling stupidity, but controlling creativity (a view popular 
amongst "artist"/"painter" programmers). So here the programmers are not 
dumb, but still they need to be kept in line with rules, constraints, 
specifications, strict APIs, etc.. You can't do anything too strange or 
out of the ordinary, and the language is a reflection of that, 
especially with regards to restrictions on dynamic typing (and other 
dynamic stuff like runtime class modification).

Unfortunately this emotional response is often not fully conscious, or 
at least, it is not clearly expressed to others by the underlying 
programmer. And once this happens, _everything is lost from the 
beginning, in terms of trying to have a sensible debate._ Because from 
now on, these programmers will use half-baked arguments to try to 
justify their preference of dynamic languages. The arguments will be 
half-baked because they will try to argue in the area of effectiveness 
(programmer productivity), yet the main reason they like/dislike the 
language is the attitude of the language creators and/or community. 
(Interestingly enough, an incredibly similar cognitive-dissonance driven 
fallacy happens in discussions of actual political ideologies)

(Note, I'm not saying this is the case with all programmers, or even 
most, of the proponents of dynamic typing. In particular, nor I am 
saying it's the case with Ary :p )


BTW, for a while I was quite okay with this talk, because the author 
seemed to make clear what the liked about Ruby was the underlying 
attitude. He mentioned the language design goal of "making the 
programmer happy". He mentioned all those quirks of the community like 
the 'second' property, the 42 one, the cheerleaders at the convention, 
etc.. But then he made those comments about how static typing is there 
in Java and other languages because it is thought programmers are too 
stupid to be able to handle things otherwise (don't remember his exact 
words), or even worse, the comment/point about how many programmers in 
the audience made a bug because of not specifying a type... And from 
that point it was easy to go downhill, and indeed the talk did. Although 
I am happy for him making that explicit parallel with political 
ideology, it illustrates my point very well, even if not all Ruby 
developers would agree with him 100%.


Note that all of what I said above is a comment about the nature of the 
discussion of static vs. typing. I didn't make an actual argument for or 
against static typing (in case you were thinking this was the 
intention). I won't do that now, I'll just say that, not only I am a 
long-time proponent of static typing, in the last few years I've become 
a proponent of *even more* static typing. But done in a smart way of course.


-- 
Bruno Medeiros - Software Engineer