From: ram@zedat.fu-berlin.de   
      
   Salvador Mirzo  wrote or quoted:   
   >I've read the Early History of Smalltalk, by the way.  I think I   
   >understand what he means by ``messaging'', ``local retention and   
   >protection'' and ``hiding of state-process''.  My knowledge reaches its   
   >limits a bit in ``extreme late-binding of all things'' and I get   
   >certainly puzzled in ``it can be done in Smalltalk and in LISP'' given   
   >that he is ``not aware of [others]''.   
      
     Object-oriented programs contain expressions to describe the sending   
     of messages at runtime. Here's an example of such an expression:   
      
   o s: x   
      
     . "o" is the receiver object, "s" the selector (keyword) of the   
     message, and x is an argument.   
      
     "Extreme late-binding of all things" to me (S. R.) means   
     that it is possible to give the the values of "o" and "x"   
     (including their types) only as late as immediately before   
     "o s: x" is being evaluated (executed).   
      
   >Now, to address my main puzzle.  The email is from 2003.  Alan Kay was   
   >certainly aware of Python, Java and so on.  Why would his notion of OOP   
   >be impossible in Python or Java?   
      
     He might have some criteria he has not mentioned.   
      
     For example, in Smalltalk, blocks of code are objects, too,   
     and you can define your own custom bool type and "if" statement   
     using Smalltalk and such blocks. Maybe he requires that, in   
     an object-oriented language, blocks of code are objects, too. [1]   
      
     In LISP, you can have code values using "LAMBDA", and maybe   
     that's the criterion Alan Kay used, as both Smalltalk and LISP   
     have code block as run-time values.   
      
     In Python and in Java there also are non-object-oriented features,   
     and maybe he requires that, in an object-oriented programming   
     language, everything has to be done in an object-oriented way;   
     what might be called a "/pure(ly)/ object-oriented language".   
      
     Maybe he requires metaclasses. Well, Python has them!   
      
     [1]   
      
     So, you define two classes "True" with   
      
   ifTrue: aBlock   
     ^aBlock value   
      
     and "False" with   
      
   ifTrue: aBlock   
     ^nil   
      
     . Now we have implemented an if statement using polymorphism   
     that can be used as:   
      
   a > 0 ifTrue: [a := 0]   
      
     . I have not checked this code on a Smalltalk implementation.   
     Maybe it needs some additions or modifications, but it gives   
     the general idea.   
      
   An attempt to emulate this in Python:   
      
     main.py   
      
   class True_:   
       def if_true( self, block ):   
           exec( block )   
      
   class False_:   
       def if_true( self, block ):   
           pass   
      
   class Boolean_:   
       def __new__( self, value ):   
           return True_() if value else False_()   
      
   a = -2; Boolean_( a < 0 ).if_true( "print( 'It is true!' )" )   
   a = +2; Boolean_( a < 0 ).if_true( "print( 'It is true!' )" )   
      
     output   
      
   It is true!   
      
     . I used "exec" to emulate block objects, one could also use   
     "lambda" (but it is restricted in Python) or a form of "def".   
      
   --- SoupGate-DOS v1.05   
    * Origin: you cannot sedate... all the things you hate (1:229/2)