>>>>> "Jim" == Jim Weirich <jim / weirichhouse.org> writes:

    Jim> I think Ville means that making join a method on a list means
    Jim> that lists must now know about strings.  Unfortunately,
    Jim> removing join as a list method still leaves lists
    Jim> knowledgeable about string for every object implements a to_s
    Jim> method.

I mostly meant that the sequence has a special case for the list of
strings. We have __str__ in Python too, but ''.join doesn't call it:

>>> '-'.join([12,13])
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
TypeError: sequence item 0: expected string, int found

Calling to_s() seems kinda brutal from the Python POV. Perhaps this is
one of the areas where Ruby chooses the follow the Perl school of
Convenience.

    Jim> BTW, neither form is "more OO"  than the other.

And more importantly, "more OO" isn't the end-all and be-all of good
design.

    Jim> Stateless programming means writing code that calculates a
    Jim> result without changing the state of the program as it
    Jim> executes.  This style of programming has many advantages, but
    Jim> neither Ruby nor Python adheres to this style, except in
    Jim> small snippets of code.

Yes, typically. That's because neither optimizes the tail recursion to
a constant space operation.

    Jim> A functional language treats functions as first class data.  This means 

Yes, and Python does too.

    Jim> performed on these functions that produce new functions.  A
    Jim> higher order function (in my perhaps flawed understanding) is
    Jim> a function that takes other functions as operands.

.... or returns new functions.

    Jim> builds objects out of them.  And what is really surprising is
    Jim> that despite the rather fundamental differences in their
    Jim> semantic foundation, the languages are more alike than they
    Jim> are different!

Yes, Ruby and Python are not all that different. I guess most Ruby
fanatics would be quite happy with a forked version of Python. Adding
most of the features Ruby people love would be quite easy (some, like
sequence.join would be trivial), it's just that the core Python
developers have chosen not to implement them for one reason or
another.

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