[self-interest] Paper on Traits.

Jan-Paul Bultmann janpaulbultmann at me.com
Sun Sep 25 18:22:21 UTC 2011

On Sep 25, 2011, at 19:51 PM, Jecel Assumpcao Jr. wrote:

> Jan-Paul,
> It is very important to note that some words are used in different ways
> in different projects. Otherwise you can have some very confusing
> discussions.
> "Traits" in Self come from Adele Goldberg's teaching scheme for early
> Smalltalk where she purposely used different words than the standard
> jargon to informally introduce ideas before moving on to the actual
> details for the language. So she would first get people to think about
> which "traits" an object might have before showing them the "class" that
> implemented the idea.
> Beyond "traits", Self also has "mixins". These names are just
> conventions and at the language level we just have parent objects, but
> the different names indicate the different intent behind these objects.
> Several languages, including Strongtalk which evolved from Self, have
> "mixins" as an important feature. So when the research group at Bern
> decided to add to Squeak a modified version of "mixins", they decided to
> use a different name so their changes wouldn't be overlooked. That is
> what "traits" in Squeak or Pharo are. This has been copied in several
> other projects and languages and so is currently what is normally
> understood by the term. This is, however, different from what is
> described in the paper that David indicated.
> Back when JIT implementations were less common, one term that caused a
> lot of confusion was "compiler". For Smalltalk-80 the term meant the
> source the bytecode translation program while for Self that was called
> the "parser" and "compiler" meant the bytecode to native machine code
> translator instead.
> > Btw, Davidmay I humbly ask you on your thoughts on Io as a language ^^?
> > Another grab bag one, or maybe a worthy successor to Self if enhanced
> > with its Environment ;)?
> I am not David (either one ;-) , but I have been a part of the Io
> community since the very beginning. This is another case of the same
> words being used differently and causing confusion. Io comes from the
> Newtonscript tradition of "prototypes", not the Self style. Even Steve
> Dekorte was confused about this for a very long time, and I can't blame
> him since when I first read "The Power of Simplicity" paper I also
> imagined something like Io rather than what Self actually is. But those
> ideas are actually from Henry Lieberman's 1986 "Using Prototypical
> Objects to Implement Shared Behavior in Object-Oriented Systems" paper
> instead.
Yeah the naming clash is amazing especially when one works with projects that used terms before everybody else did^^
Thanks for the insight on the different origins :D

> While I like Io, it has never had the kind of implementation technology
> that Self has always had and which recently has also come to Javascript.
Yeah we're kinda working on that with the recent acute implementation^^
One problem with this is though that Oracle still holds a lot of Davids original patents so were a bit hesitant about implementing all the power of Self.
Most of them run out in 2014 I think, there are a lot of projects though that are bold enough to simply implement them, but with Oracles recent suing happines its kinda difficult ^^

> That community is actually smaller and currently less active than the
> Self one, so I wouldn't expect world domination from that direction any
> time soon.
Smaller yes, less active no. :) You should really visit the #io channel on irc.freenode.net

Io has the advantage that it is conceptually simpler than Self, so there are more concepts that can arise out of a small base language, like resends and annotations.
There are vastly parts missing though like Morphic and the Image. But it has a far superior concurrency model.
Interestingly we can get a Self like look with acute ^^ by encouraging small number of arguments and having a single arg syntax.
list(1,2,3) at:1 data
list(1,2,3) at:1 put:5
As at: returns a listIndex.

Currently we are working on a VM for Prototype languages, it could be interesting to combine the small working force of the Self and Io communities.
When lookup is just a slot on Objects (as we plan to do it) it would be trivial to implement different Inheritance models and thus support both languages :) the rest is just syntax^^

Cheers Jan
> -- Jecel

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.selflanguage.org/pipermail/self-interest/attachments/20110925/abd467d4/attachment.html>

More information about the Self-interest mailing list