>>>>> "James" == James Britt <jamesUNDERBARb / neurogami.com> writes:

    James> I haven't much to add, except I, too, had the same reaction
    James> to the "#{ruby_feature} works for small projects, but will
    James> burn you on the large ones" comments.  I immediately
    James> thought of those who argue for static typing, claiming that
    James> it is somehow essential for large-scale development while
    James> never quite backing up the claim.

Alright, let's assume that we have a function f that should always
return a string.

output = "".join([f(entry) for entry in [1,2,3,4,5,6] ])

If f suddenly returned something else, it's usually indicative of an
error of some kind. Too bad this error can easily go unnoticed if the
code is in production. OTOH, if the implicit conversion wasn't done,
the customer would just call you and said "the code crashed, and I got
this exception traceback..." which immediately points you to the right
line of code.

    James> Now I have that tune in my head, trying hard not to make up
    James> words about dynamic typing and implicit conversion.

No need to make up words about dynamic typing, I'm a big advocate of
that (which maked this a bit of a strawman argument). This was merely
about debunking the claim that implicit conversion is somehow an
example of duck typing, whereas duck typing also has the flip side of
the coin - if it doesn't quack and walk like a duck, it's not a duck,
and an exception is in order.

    James> But, for some, those things really are the wild side, and
    James> not everybody is ready to take that walk.

Aren't you blowing this out of proportion? Would Python be on the
'wild side' if it added the following function:

def join_as_strings(seq, sep):
    return sep.join([str(s) for s in seq])

See? Everyone can opt to choose the Ruby way in Python too, it's just
not the default because it's deemed dangerous and a violation of
"explicit is better than implicit".

I think this thread has been an interesting example of how similar the
two languages are - it started from "Python OO is a hack, Ruby is
better in FP also because it supports List Processing" (someone still
needs to tell me what List Processing is in Ruby) but it all really
boils down to are these small cultural differences. And they have been
hashed again and again in the past.

I bet you could use either language, and get exactly the same
productivity.

-- 
Ville Vainio   http://tinyurl.com/2prnb