Gary Willoughby: "Why Go's design is a disservice to intelligent programmers"

[Idan Arye via Digitalmars-d-announce]

On Monday, 30 March 2015 at 07:45:50 UTC, Paulo  Pinto wrote:
> On Monday, 30 March 2015 at 03:26:14 UTC, deadalnix wrote:
>> On Sunday, 29 March 2015 at 16:32:32 UTC, Idan Arye wrote:
>>> Computer science is all about tradeoffs. I used to love Ruby, 
>>> but then a Rails project got out of hand... Nowadays I use it 
>>> mainly as a bash replacement - Hundredfolds more expressive, 
>>> only a tiny tiny bit syntax overhead, and for things that 
>>> bash's safety would be enough Ruby's certainly suffices.
>>
>> This is pretty much the recurring story with ruby. The first 
>> 10 000 lines are a lot of fun, and then it gets out of hands.
>
> Just like any other language with dynamic typing.

This has more to do with the module system than with the typing. 
In Ruby, the `require` function reads a source file and 
interprets it in the global namespace. This means that from that 
point on, all symbols declared in that source file(and the source 
files it `require`s) are now part of the global namespace and 
accessible from anywhere(even from places that didn't `require` 
it), and that all monkey-patching done in that source file from 
now on applies *everywhere*.

Compare it to Python, that has a module system that handles 
namespacing and forces you to `import` a module in each scope you 
want to use it. This means that if foo.py uses stuff from bar.py 
it must `import` it directly and can't rely on some other baz.py 
that might dropt it's `import` to bar.py because it no longer 
needs it without knowing that foo.py was using it.

Note that Ruby does has `module`s that can be used for 
namespacing(or for mixins...) but using them is a hassle, because 
you either have to always use fully qualified names or to `mixin` 
them into the current namespace(which propagates to other scopes 
that want to use stuff from YOUR namespace...)

Also note that Python also has ways to mess with the gloabl 
context - but you have to actually dig in to do this, compared to 
Ruby where messing up the global context is the standard way of 
doing things.