[self-interest] languages (was: Small announcement)

[Kyle]

On Thursday 04 January 2001 11:07, Jecel Assumpcao Jr wrote:
> On Mon, 01 Jan 2001, Dru Nelson wrote:
> > I have created a Self like language called 'Cel'.
>
> This is great!
>
> I think that this list is the right place for discussions of Self-like
> languages like this, Kyle's TSOL and Joseph Osako's ideas. Here is a
> less Self-like language that might also interest people in this list:
>
>    http://www.ericsworld.com/Mark/HTML/Avail.html
>
> Happy 2001, a Self Odyssey
> -- Jecel

Yes, Avail is interesting.  There was an ongoing thread about it on the 
Concatenative mailing list for a while.  

Since Self brought prototypes into focus for many people for the first time, 
it is a prototype of a prototype-based language (there were others, but not 
as widely used or seen).  Each of these languages, if triggered by Self, 
really applies the basic programming concepts from Self to the language as a 
whole.

All languages have boundaries that define what is "in" the language and what 
isn't.  Even the most reflective languages usually have some dark corners 
that aren't really accessible within the language itself.  Self is no 
different in this regard.  One of the things that I never really understood 
was why the compiler was not written in Self.  You cannot change the 
internals of the Self compilation system through Self.  Similarly, the VM is 
not accessible.

Reflection has its costs too.  For instance, imagine changing the VM slightly 
and just a little too late finding out that there is a bug in your new 
code...  Forth allows you to change virtual (or really all?) everything in 
the language.  It is rather easy to have enough knowledge to be dangerous in 
Forth.

Some languages simply do not try to cover everything.  Pascal comes to mind 
here.  The language is fairly clean and clear, but it is quite limited.  C 
lets you get to the "bare metal" and you pay for it with the lack of GC, 
pointers and all the interesting (but terminal) things you can do with them.  
Java stears away from too much reflection.  You can look at methods and 
classes etc., but you can't change the GC system or the VM from within Java.

Squeak comes close to finding a good balance.  While the system is all in 
Smalltalk, you can recode the VM and the GC system and then have the system 
re-emit this as C code.  Thus, there is a reintroduction of the 
edit-compile-debug cycle on a larger scale than is usual in Smalltalk.  I 
would love to see a Self-like system that is much like Squeak.  One of the 
beautiful things about such a system is that you can have a working 
environment and use it to replumb itself!  Carefully of course :-)

Classes have always bothered me a bit because I kept thinking about Plato's 
allegory of the cave.  OO systems are about modelling and "real life" is 
messy, not some platonic ideal.  Classes are a useful implementation tool, 
but it seems like bookeeping that is best left to a compiler or automated 
system rather than the programmer.  When I first saw Self described in about 
1989, I was fascinated because it seemed like the first time that I had seen 
a system when the things you care about (the entities that make up the 
system) are the things you manipulate.  How do you change an object in 
Smalltalk or C++?  You don't change the object, you change its class.  This 
indirection removes the immediacy and intuitiveness of you interactions with 
the system.

In short I think that prototype systems model the way that we think more 
closely than those based on classes.  When 32K was a lot of memory for a 
mainframe, perhaps FORTRAN and COBOL were the best possible ways to view 
computation.  When it is hard to find a desktop with less than 64MB of memory 
and a processor capably of over 500 million useful instructions per second, I 
don't think that the same restrictions apply.

Best,
Kyle