What could be a start would be to remove instance variable accesses and 
have only message send
even if the compiler should inline them.

Stef

On samedi, novembre 23, 2002, at 03:58  pm, Stephen Pair wrote:

> It's fun to think about ways of simplifying syntax.  In some ways, I
> like Self's implicit "self"...I also like thinking about blocks (and 
> how
> to reconcile them with normal methods).  Blocks are different from
> methods in the following ways:
>
> - they are not in the method dictionary
> - they do not have a name (and are not called by name)
> - they have access to the activation state of their home method
> - they have different syntax for expressing them
>
> There are probably other differences...but I like to think about these
> differences and then try and envision a syntax (and perhaps a meta
> model) that would accommodate methods and blocks in a more general way.
>
> Also, making the "self" keyword implicit has the effect of making
> portions of your code look more functional in nature (even though it's
> no less object oriented).  A full listing of the methods for a given
> object would look strikingly similar to a nicely designed C program
> where all of the functions in a given source file are designed to
> operate on a given set of variables that are global to the code in that
> source file (and which point to the elements of a structure).
>
> - Stephen
>
>> -----Original Message-----
>> From: squeak-dev-admin at lists.squeakfoundation.org
>> [mailto:squeak-dev-admin at lists.squeakfoundation.org] On
>> Behalf Of David Farber
>> Sent: Saturday, November 23, 2002 12:47 AM
>> To: squeak-dev at lists.squeakfoundation.org
>> Subject: brain fever
>>
>>
>>
>> Imagine a read-eval-print session that went like this:
>>
>>> []
>>      ObjectLiteral[0xD000]
>>> [] value
>>      ObjectActivation[0xD001]
>>> `d
>>      Character[`d]
>>> [`d] value
>>      Character[`d]
>>> [:char | `d] value :`c
>>      Character[`d]
>>> [:char | char] value :`c
>>      Character[`c]
>>> [| char :[`d] |
>>   [> self char] value
>>      Character[`d]
>>> [:char | char :[char] |
>>   [> self char] value :`c
>>      Character[`c]
>>> [:char | char :`d |
>>   [> self char] value :`c
>>      Character['d]
>>> ([:char | char :[char] |] value :`c) char
>>      Character[`c]
>>> ([:char |
>>  +|> char :[char]
>>  +|> change :[char :`d] |]
>>   (> value :`c) change; char
>>      Character[`d]
>>>
>>
>> OK, so I did gratuitously change some syntax around:
>>   `d => $d
>>   object msg :arg => object msg: arg
>>   var :object => var := object
>>
>> I'm sure there is lots to nit-pick about; for instance, I
>> think a lone vertical bar is ambiguous.
>>
>> But I mostly just let the ideas play themselves out; and I
>> must admit that I am very pleasantly surprised--that, of
>> course, must mean that someone already had this idea long ago.
>>
>> david
>>
>> --
>> David Farber
>> dfarber at numenor.com
>>
>>
>
>
>
Dr. Stéphane DUCASSE (ducasse at iam.unibe.ch) 
http://www.iam.unibe.ch/~ducasse/
  "if you knew today was your last day on earth, what would you do
  different? ... especially if, by doing something different, today
  might not be your last day on earth" Calvin&Hobbes