A while back I tried out SuperCollider for programmatic music generation... I distinctly remember thinking, "this language feels like some weird awkward blend of Smalltalk and Ruby".

Somehow I hadn't thought of the two as similar or related to each other.

Anyway, certainly you can write in this style in Python, since functions are first-class objects. It just has limits on its anonymous functions, and doesn't happen to provide a `times` method on integers (at least partly because the old parser would have struggled with seeing `10.times` and thinking "this should be a floating-point number, but `t` isn't a decimal digit").

  >>> class rint(int): # r for Ruby, of course
  ...     def times(self, func):
  ...         for i in range(self):
  ...             func(i)
  ... 
  >>> rint(3).times(print)
  0
  1
  2

> In Python, Java or C++, calling object.method() asks the compiler to find the method in the class and call it.

This is incorrect, as noted later. In Python, the lookup occurs at runtime. It also checks the object first, in most cases.

... The writing keeps anticipating my objections and then sort of correcting them and leaving something else not quite right. So trying to edit as I read has been frustrating. The point being, I just don't buy the philosophical difference that the author is trying to draw.

In Python the reason you're dealing with "attributes" rather than "messages" is because functions are first-class objects, which entails that they'll be treated the same way as ordinary data. A method call is two separate steps — the method-lookup and the actual attempt to "call" the result — which also has the implication that you can cache a "bound method" for later use. (By comparison, Ruby lets you "cache" the symbol, which in Python-think looks like some kind of magic string that tries to look itself up as an attribute name on other objects.)

But, I contend, this doesn't meaningfully change how the language is used overall.

> By including Enumerable and by implementing each, we get access to so many methods that we didn’t need to manually implement.

Okay, but in Python `map` and `filter` are just builtin functions, and you can use list comprehensions and `functools.reduce`. It's just a difference between external and internal iteration.