Why Ruby?

[retard]

Tue, 21 Dec 2010 19:50:21 +0000, Bruno Medeiros wrote:

> 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.

My experiences in several language communities have shown that 
programmers easily resort to emotional, completely irrational arguments. 
It's best to avoid these kind of arguments as much as possible. 
Passionate people seem to favor this juxtapositioning.

For example, the static type systems develop further each day. These 
aren't even supposed to be practical in the real world in their current 
state. At least I hope we can cherry-pick the best parts and build a 
practical language once the underpinnings are clearly studied and 
specified. It's just plainly stupid to compare these now.

One reason I favor dry theoretical programming books is that they often 
cite concrete facts and describe the logical reasoning leading to a 
conclusion. The other group of books, programming cook books, are mostly 
just pure poop:

"Book: You must always do A and should also prefer choices like B."

"Me: why?"

"Book: Just do it, don't think."