Lessons learnt from the Self archive

Bystroushaak bystrousak at kitakitsune.org
Wed Jun 15 06:51:30 UTC 2016

[Repost of the 

I’ve spent 26 days reading 26 years of messages from the Self mail 
conference archive </2016/06/09/self-mail-conference-in-mbox/>. Here is 
what I’ve learned. Please note, that everything is highly subjective and 
may be even wrong.

    Interesting messages

If you don’t want to go through all 4334 messages of whole archive, you 
may read just this dataset, which contains only 295 messages I’ve found 
interesting enough to save into separate directory. I’ve saved each 
message because it answered some of the questions I had, or because it 
was marking important milestone in Self development.

  * https://github.com/Bystroushaak/self_mbox/raw/master/datasets/self-interesting.mbox.lzma

    List of alternative languages / interpreters

When I’ve got to year 2004, I’ve realized it may be valuable also to 
store list of alternative interpreters and languages, which were sent to 
the conference, so I’ve began to collect them too. When I finished the 
reading, I’ve spent an hour by scanning the 1990-2004 timeframe, but 
I’ve maybe skipped something.

  * https://github.com/Bystroushaak/self_mbox/raw/master/datasets/self-alts.mbox.lzma

Just to give you the idea, here is the reduced list of topics (there is 
more in the archive):

  * tinySelf progress report
  * JSelf Home Page
  * Announcing OpenSelf
  * A Self _ BETA Language Hybrid Project
  * premature announcement: SELFISH
  * Brain language
  * SELF for VisualWorks 5i
  * dSelf
  * New release of Cel
  * Self_R not started yet
  * Io
  * Zero, a programming system
  * [ANN] Slate 0.3 Released!
  * Re: Self for Squeak
  * Klein open-source release
  * Self-style outliners for Javascript
  * Phos
  * Anyone have a copy of Kevo?
  * Re: Distributed Objects
  * Re: UnitTests
  * AmbientTalk
  * Self in Javascript progress
  * Re: Self in Javascript progress
  * Re: goals (was: dynamic deoptimization)
  * Pooi: A prototypical object-oriented interpreter
  * Avacado: JavaScript trying to be more like Self
  * BOS1.2 release — play it again, sam
  * Smalltalk interpreter of Self

    Everything is dead, or dying

Self is small project maintained, discussed and used by only handful of 
people over two and half decades (one generation). It is slow game, and 
changes may take years (new releases), or decades (porting to new 
systems). This leads to massive link rot 

It may not be evident if you are just participating from time to time, 
but when you look into archive, it is a clear trend. Only a few people 
were able to keep attention and interest over the decades and maintain 
resources they created. There were a lot of those who lost interest or 
just didn’t have the time and their resources are dead.

Beginning of the Self conference archive is in 1990, which was a few 
years before the HTML and HTTP was invented.

I have no idea, how people organized work and thoughts in groups at that 
time (text files via FTP maybe? telephone and paper notepads?), but it 
is either converted to a few existing HTML resources, or (most likely) 
dead. You won’t see the design decisions, discussions or thoughts from 
that time.

Then HTML and HTTP came. People were excited about this new protocol:

     From urs at cs.stanford.edu Sat, 19 Mar 1994 11:53:23 PST:

    Thanks mostly to Bay-Wie Chang, Self now has a Mosaic home page,


    All of our material continues to be available via ftp, but the Mosaic
    interface is definitively friendlier (e.g., it has an online
    bibliography and paper abstracts).



It was definitely an improvement. But idea to create articles and 
webpages about Self and put them on your web lead to massive resource 
fragmentation. I am not criticizing, merely pointing to a fact, that 
almost every link from that time is dead, because it was not maintained 
in long-term and that whole situation is actually unmaintainable by one 
person, even if that person really wanted to maintain it. That url in 
the email is by the way – dead 

When you think about it, almost every time anyone counted on third-party 
service, it didn’t pay off. From that point of view, everything is 
dying, we just don’t see it, because it still exists. But for the future 
newcomer to Self, it is already dead.

If you think in the time-frame of decades, all providers of services 
will end, often without replacement. Look at geocities for example. Once 
it was hosting for hundreds of thousands of webs. Now it is dead. 
Sourceforge killed itself by adding adware to user’s packages, and Yahoo 
is slowly dying and it is only matter of time until someone will buy it 
and shut down most of its services for good, because it is not 
profitable. University pages are chapter for itself, because almost all 
of them are dead soon after the person who created them leaves the 

Even if the webarchive or other web cache archives the original, this is 
not the long time solution. There are various copyright attack in place 
right now, which may cause such services to close.

This may not look like a big issue, but for newcomers, this means that 
half of the valuable resources is not available.

If you look at what survives, it is almost always only files which were 
downloadable and thus shared by large number of people. In this sense, 
git is the best solution, because it allows everyone to clone the 
repository and synchronize it with others, even if the original resource 
is gone.

There is two possible options on how to overcome this problem:

  * distributed standalone information resources shared by everyone
  * maintained centralized group resources

If you create your own webpages, make them easily downloadable and 
sharable. Otherwise, they will be dead soon (5-20 years from now). Other 
option is to write articles in postscript / PDF and generally standalone 
files, which will be distributed to large number of people.

Second option is to make central repository of knowledge consciously 
maintained and hosted over the years by Self community at one place. 
Preferably in the form of Wiki. I will get back to this later.

      Honorable mentions

        FTP that refused to die

    Date: Fri, 25 Aug 1995 12:45:08 +0200
    From: rainer at physik3.gwdg.de (Rainer Blome)
    To: self-interest at self.sunlabs.com
    Subject: non-official ftp site in germany (solaris only)

    The link speed to Sun was really not acceptable when I tried it, so I was
    glad to be able to get Self from Manchester.  Seems that I have been lucky
    now that the site is down.  The FTP admin of our local computing centre was
    so kind as to put Self 4.0 on his server.  It is not official and may
    vanish any time, but they have lots of disk space and I suppose it won't.
    Still, please don't use this site unless it is a lot faster than your link
    to the USA.

    Since the stuff is the one that I used to install Self here,
    it doesn't look exactly like the original (all files have the Self-4.0
    prefix) and it is not complete (I only installed the solaris version).

       total 12110
       -rw-rw-r--   1 emoenke         1475 Jul 26 17:05 Self-4.0.Install
       -rw-rw-r--   1 emoenke         1933 Jul 26 17:04 Self-4.0.LICENSE
       -rw-rw-r--   1 emoenke         1087 Jul 26 17:05 Self-4.0.README
       -rw-rw-r--   1 emoenke        71809 Jul 26 17:05 Self-4.0.readThisFirst.ps
       -rw-rw-r--   1 emoenke     12320062 Jul 26 14:16 Self-4.0.solaris.tar.gz

    Also, the tar file is gzipped instead of compressed.  Not having patched
    the install script, it won't work anymore (unless you linked zcat to
    gzcat), but what Install actually did was just a single line anyway:

    gzip -cd Self-4.0.solaris.tar.gz | tar -xfpB -

    Greetings, Rainer

The FTP is still there, but sadly the Self directory isn’t.


Jecel Mattos de Assumpcao Jr <http://www.merlintec.com/lsi/jecel.html> 
is my new personal hero.

Not only that http://www.merlintec.com/ still works and didn’t lose any 
of its contents, also his messages on various topics in the conference 
were really great and it was pleasure to read it.

    Self is really complex

There is 114 821 cloc <https://github.com/AlDanial/cloc> lines of C++ 
code (counted without comments, blank lines and so on). There is two 
kind of compilers (NIC, SIC), assembler and other platform-dependent 
stuff. Almost none of it is documented outside the code itself.

This is bad. Really bad. I did a little bit of C++ back in high school, 
but I can’t really imagine going through all this code and trying to 
make sense of it.

It is extremely hard to get an idea what Self really is, what parts is 
it made from. Best thing documenting how Self works is this schema from 
the handbook:

We need pictures like this that will document components of the VM. 
Schematic blueprints for what Self is and how it approximately works. 
Sometimes, pictures says more than a thousand words.

If you don’t think that this is serious, here is a list of reasons:

  * It is hard for beginners to even get the idea what Self is. We know,
    that it is a language, but it is also virtual machine, bunch of
    compilers, memory managers and what not. It is almost like small
    operating system.
  * It is hard for anyone who wants to contribute to get an idea where
    to do the change.
  * It is hard for anyone who wants to port the Self to another
    architecture / OS.
  * It leads to fragmentation. People rather create own forks, or whole
    new languages rather than to try to make sense in so much C++ code.


An example of the complexity of Self was its porting to Linux. First 
message about porting to Linux was probably this:

     From dirkst at POOL.informatik.rwth-aachen.de Tue, 18 Aug 92 11:04:58 PDT
    From: dirkst at POOL.informatik.rwth-aachen.de (Dirk Steinberg)
    Date: Tue, 18 Aug 92 11:04:58 PDT
    Message-ID: <9208181757.AA24531 at messua.informatik.rwth-aachen.de>
    MIME-Version: 1.0
    Content-Type: text/plain


    I have recently read about Self and ftp'd some papers from self.stanford.edu,
    I even got the sun4 version of Self 2.0 and played around with it for a few
    minutes. Otherwise, I have no experience with Self whatsoever, but from what
    I read I am kand of enthusiastic.

    My question: Is anyone porting Self to some other platform, maybe even to the
    386? I have Linux running on a 486/33 w/ 16 Meg RAM and 500 Meg HD, which should
    be a workable system for Self; I have gcc-2.2.2 and libg++-2.2, so it should be
    possible to compile the virtual machine (judging from the README's).
    BUT: I have the feeling that the compiler really generates native SPARC code and
    so one would have to write a completely new backend and assembler for the 386.
    I guess that would be a *major* project!?? Is the compiler/assembler written in Self
    or C++? If Self is tied to the SPARC achitecure and inherently non=portable, then
    that would nagatively influence the impact that this exciting software could have.

    How about using the gcc backend?

    Thanks for any info,


    Dirk Steinberg
    dirkst at pool.informatik.rwth-aachen.de

This is from 1992. First (not fully ported) Self for Linux came in 1999, 
by /Gordon Cichon/, but that wasn’t really much usable, from what I’ve 
read. Proper support with GUI and everything working nicely took several 
more years.

    The bus factor is low

As the wikipedia <https://en.wikipedia.org/wiki/Bus_factor> says:

    .. the bus factor is a measurement of the concentration of
    information in individual team members. It .. connotes the number of
    team members that can be unexpectedly lost from a project (“hit by a
    bus”, as it were) before the project collapses due to lack of
    knowledgeable or competent personnel.

The bus factor of Self is incredibly low. From my own estimate based on 
reading the archive, I would say it is 5, maybe 7 if you want to be 
optimistic, probably 3 if you want to be pessimistic.

This is not just bad, because it threatens existence of Self alone, but 
mostly because it also means that there is extremely low number of 
people, who /really/ understand Self, and almost no documentation, which 
can train new experts.

Wikipedia offers following solution to increase the bus factor:

    Several ways to increase the bus factor (thus making the project
    more resilient) have been proposed:

      * Reduce complexity
      * Document all processes and keep that documentation up-to-date
      * Encourage cross-training.

I don’t think, that there is much space for reducing the complexity, but 
second and third point may be solvable by community Wiki.

YWAM KnowledgeBase 
also mentions two more interesting points:

      * maintaining documentation about how the corresponding website is
      * forum for learning from each other

Again, both points may be solved by community Wiki. Especially the 
second point is really important.

    Collected resources

I’ve collected following links, which are not yet dead, or were archived 
by webarchive. I didn’t yet have time to go over them, so I am sharing 
them as I added them to my todolist:

 1. http://kleinvm.sourceforge.net/
 2. https://github.com/aausch/klein
 3. http://adamspitz.github.io/Avocado/
 4. https://github.com/jmoenig/morphic.js
 5. http://lively-kernel.org/
 6. http://web.media.mit.edu/~lieber/Lieberary/Softviz/CACM-Debugging/Kansas/Kansas.html
 7. http://www.self-support.com/
 8. http://www.princeton.edu/~achaney/tmve/wiki100k/docs/Self_(programming_language).html
 9. https://web.archive.org/web/20010813120828/http://www.mri.mq.edu.au/~kjx/tgim.html
10. http://merlintec.com/swiki/Self/2.html
11. http://merlintec.com/old-self-interest/threads.html
12. https://web.archive.org/web/20050121084338/http://www.lsi.usp.br/~jecel/merlin.html
13. http://www.merlintec.com/lsi/merlin.html
14. https://web.archive.org/web/19980123025609/http://www.cs.unm.edu/pad++/begin.html
15. https://web.archive.org/web/20040607063757/http://linus.socs.uts.edu.au/~cotar/proto/programme.html
16. https://web.archive.org/web/20080307022735/http://www.consultar.com/JSelf/
17. This file, when read into the initial Self system (empty world)
    creates just the objects needed to run a simple program that prints
    a table of factorials up to 49! and then stops.
18. https://web.archive.org/web/19991006225113/http://www.consultar.com/JSelf/Links.htm
19. https://web.archive.org/web/20001109105100/http://www.consultar.com/JSelf/
20. http://www.linuxsupportline.com/~openself/
21. https://web.archive.org/web/20010405022406/http://openself.seul.org/
22. https://web.archive.org/web/20070221212847/http://www.lsi.usp.br/~jecel/tut1.html
23. https://web.archive.org/web/20000815211509/http://www.research.microsoft.com/ip/
24. https://web.archive.org/web/20080225110457/http://www.lsi.usp.br/~jecel/persist.html
25. https://web.archive.org/web/20000615190052/http://www.squeak.org/oopsla99_vmworkshop/jecel.txt
26. https://web.archive.org/web/20000817004328/http://www.squeak.org/oopsla99_vmworkshop/
27. http://www.merlintec.com/selfvmdoc/
28. https://sourceforge.net/projects/selfish/
29. http://www.3plus4.de/self/
30. https://web.archive.org/web/20000504145352/http://www.sun.com/research/self/papers/craig-thesis.html
31. https://web.archive.org/web/20010605131725/http://www.sun.com/research/self/papers/urs-thesis.html
32. http://www.ag-nbi.de/research/dself/
33. http://selfguru.sourceforge.net/
34. http://ftp.squeak.org/docs/OOPSLA.Squeak.html
35. https://web.archive.org/web/20150220064600/http://www.comtalk.net/Squeak/95
36. http://merlintec.com/swiki/Self/1.html
37. http://stefan-marr.de/tag/roarvm/
38. http://merlintec.com/lsi/tiny.html
39. https://dl.dropboxusercontent.com/u/1803213/CS294/8%20Self%20VM%20internals.pdf
40. https://www.cs.ucsb.edu/~urs/oocsb/self/index.html
41. https://liveprogramming.github.io/2013/papers/avocado.pdf
42. http://c2.com/cgi/wiki?SelfLanguage
43. https://news.ycombinator.com/item?id=7047953
44. http://stackoverflow.com/questions/tagged/selflanguage
45. https://www.infoq.com/presentations/oop-language-context
46. http://xanadu.com/zigzag/
47. http://www.nongnu.org/gzz/gi/gi.html
48. http://www.merlintec.com/download/
49. https://learnxinyminutes.com/docs/self/
50. http://rosettacode.org/wiki/Category:Self
51. https://vimeo.com/118826521
52. http://homepages.ecs.vuw.ac.nz/~servetto/Fool2014/FundationForObjectAspectAndContextOrientedProgramming
53. https://www.researchgate.net/publication/285512303_Persistence_schema_evolution_and_performance_in_the_container-based_model
54. http://rosettacode.org/wiki/Category:Self
55. http://www.gliebe.de/self/
56. https://web.archive.org/web/20070205114801/http://www.lsi.usp.br/~jecel/tiny.html
    tinyRick tinySelf
57. http://www.wolczko.com/CS294/

Next blog will contain some improvement proposals.

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

More information about the Self-interest mailing list