Bystroushaak's blog / English section / Programming / Series about Self / Environment and the programming language Self (part four; community, history, future and metaphysics)

Environment and the programming language Self (part four; community, history, future and metaphysics)

Previous episodes:

  1. Environment and the programming language Self (part one; environment)
  1. Environment and the programming language Self (part two; language)
  1. Environment and the programming language Self (part three; debugger, transporter and problems)

were mostly about the language and the environment. In today's article, we'll have a look at the community around the Self language, its history, future and also possible consequences brought by Self.

The Community

The community around Self is somewhat untraditional. It is largely made up of academics and people who have been following Self for decades. They like to read the academic articles about or based on it, but they do not usually actively contribute to the language nor the discussion.


Self was primarily created by David Ungar and Randall Smith. Both of them join the discussions from time to time.

However, now the primary project leader is Russel Allen, who hosts the official GIT repository under his github account, maintains the official website and a blog, integrates merge requests and moderates the discussions.

Another highly engaged person is Chris Double, who often comments on github but also in the mail-list. You can also meet him on an IRC channel as doublec.

Mail list

Most of the communication is done through Yahoo groups mail list. If you don't want to log into a Yahoo account, then:


If you are interested in using the aforementioned mail-list as a usenet group, I highly recommend setting up the subscription via NNTP instead of an e-mail. You can use Gmane, where you can find the group as gmane.comp.lang.self. You can use, for example, Thunderbird to subscribe. Gmane website is not fully functional after a crash, but the NNTP interface is fine.


By the method of trial and error I got to understand that mail-list isn't really good for any kind of discussion, which isn't connected to Self, and people actively mind that you are discussing there because they suddenly receive emails from a group, from which they have received twenty emails in the last 10 years.

GitHub Issues

Personally, I recommend to move all technical discussions to GitHub Issues:

These are usually attended by people who are interested in the topic and will not hate on you when you think out loud about code and possible solutions.

IRC channel

In addition, there is a semi-dead IRC channel where somebody sometimes comes and causes a discussion:


Personally, I have been idling there for over a year, and I have to say that discussions on all possible topics are welcome, it's just that most people don't actively watch that channel. Therefore it can take even days before they start to react. Certainly do not get annoyed by it and leave the client running in the background (irssi on a server) for a longer time, if you really want someone to answer.

Social networks

There is a subreddit /r/selflanguage, where the news notifications are being sent. Most of them are then resent to hackernews, /r/programming and on lobsters.


There is also a blog, but with a text width of 460 pixels, it looks really bad. Also, you are not free to write there whatever you wish and if the owner doesn't like it, then he will delete part of your text (already tried that, ehm ehm). Therefore, it's not a general blogging environment, unlike other blogging services.

Personally, what bothers me most about it, is that with its format it is absolutely not suitable for writing technical texts, and I don't only mean the editing in Wordpress, mostly it's about the displaying in a horrible noodle in the center of your screen (really absurd on 4k LCDs), which brings the worst from the mobile to your computer screens.

If you are interested in contributing there, you can send an e-mail to Russel Allen and he will make you an account within a few days. However, I would recommend you to make your own blog.

You can also subscribe to receive the blog news through NNTP:


and RSS:

Historical point of view

The first version of Self was designed by David Ungar and Randall B. Smith in 1986 in Xerox PARC, which was also the birthplace for Smalltalk, Ethernet, laser printers and much of today's graphical user interface concept.

The development then continued from 1987 at the Stanford University by the team comprising of Craig Chambers, Urs Hรถlzle, Ole Agesen, Elgin Lee, Bay-Wei Chang and David Ungar. The first versions of the compiler and of the graphical interface based on the Morphic framework had been created at that time.

In 1991, the development had been transferred to Sun Microsystems, where few versions had been published together with the prominent 4.0 version in 1995. At that time, the first work on the first JIT (Just in Time) compilers was in progress. Thanks to them, Self had been optimized to the extent that it was capable of running numerical benchmarks around the speed of half of the performance of optimized C code. Also, a Smalltalk interpreter had been implemented at that time in Self that was working faster than the native compiled versions.

Then Sun decided not to support Self anymore and decided to support Java. As Chuck McManis, a former employee of Sun Microsystems, wrote for a thread on hackernews:

Wow. For those who don't know, there was a big 'language bake off' at Sun between TCL, Java, and Self (all being funded by Sun Labs) and Bert Sutherland (then director of Sun Labs and brother of Ivan) required that the language changes stop and then we'd look at each one, and decide which one to move forward on. When the world sort of exploded at the WWW conference held in Darmstadt Germany in 1995, Java officially 'won' and both Self and TCL were de-committed. (not canceled per-se but not getting any more funding either).
I like to think that all three languages benefited from the competition.

Asked why did Java win, he replied:

At the time it was the ability to construct executable content inside a web page. Javascript now dominates that space, but up until WWWC 2 pretty much everyone was stuck with page layout primitives. It made it possible to see a path to where we are today and so everyone wanted their browser to have it, and if their browser didn't have it they could run the HotJava browser and get it.
Bottom line, it demonstrated an answer to a problem that a lot of people were having, and it promised to answer that problem in an 'open source' kind of way.

That was the end for Self for many years. It's not that it would completely disappear, but in combination with hardcoded optimizations that made it run only under SPARC processors, many people stopped caring about it.

In 1997, Sun bought Animorphic Technologies, which constituted of people, who developed the JIT optimization in Self. They created a Hotspot technology, based on their development knowledge from Self. This accelerated (then) very slow and low-performing Java to usable speeds. This way Self lost important people and one of the biggest disadvantages of Java, its slowness, disappeared.

First attempts to run Self on Linux began in 1999, but from what I understand, it was very uncomfortable and aimed at hardcore programmers. At that time, thanks to a port by David Ungar, it was possible for the first time to run Self on Apple hardware that used PowerPC processors. Macbooks were cheaper and more available than a Sparc workstation from Sun, so now, for the first time, Self could be used even by "mere mortals".

David Ungar received Dahl-Nygaard price for Self in 2009.

A year later in 2010, Russel Allen published version 4.4. It was the first version that was officially natively working on Linux. It has to be said that it was possible to run Self within the project Self4Linux since 2001. However, it still wasn't an official version. Before that, the port by Gordon Cichon from the year 1999 could also be used.

Since the publishing of 4.4, the development is still led by just a few people. The latest version at the time of writing this article is 2017.1 published in May 2017.

The Future


Nowadays, slow and sporadic works are being done on Self. They mostly consist of repairs and adjustments. I've begun to add support of Unicode to the graphic interface. Although I managed to do certain progress, I was unable to continue due to personal reasons, which made me prioritize projects and really ate my free time (I have a kid now, a different job, you know how it works..). So probably no UTF support in the foreseeable future.

The graphical interface definitely needs a lot of work. It works, but by today's standards and expectations it is really uncomfortable and merciless for users in terms of error toleration. I managed to crash the whole system several times during my first half-hour just by trying different stuff. You don't need to make any big mistake, it's enough to just make a typo in your GUI code and the system will at least freeze the GUI, if not crash entirely.

A mechanism, which is known from some Smalltalks (Pharo for example), that would enable restoration from protocol to the point before crash, or even automatic saving of some of the restoration points, was discussed many times in the email conference, but as far as I know, no real progress was made towards this feature. Furthermore, it would be nice if it wasn't so easy to crash or freeze the system.

All internal text editors need to be improved because often they don't reach even the functionality of the Notepad in Windows. Working with copy/paste buffer needs to be updated because Self works with it only in some weird 30 years old mode and you need to have autocutsel running in the background to make it work.

Personally, I think that there is a big space for improvement of the interface and the language in the form of internet project repository, from which it would be possible to install through dependency definitions. In other words; it is quite hard to distribute your own software in Self nowadays. A package manager would greatly help this situation.


There used to be a project that aimed to bootstrap Self in itself called Klein.

What's left of it can be found on Github:

If you want to continue Self development, this could be a good starting point.

I find it interesting, that you could debug Klein and connect to it from the running instance of standard Self.


Korz is a very interesting project; David Ungar had an idea about how Self would look and work if he added another dimension.

Languages that support only functions, such as C or Pascal, have only one dimension. A function receives some data.

Object-oriented languages added another dimension by interlinking functions with structures they work with. A function now receives some data and can be found in different objects which give them different meanings.

Korz adds another dimension in the form of whole worlds. Objects are stored in one or more worlds. Compared to Self, not only an object and a message are specified, but also the world, to which it should be sent. Worlds can be different, in some, for example, mirrors and functions for working with a system and a disk are missing entirely, so they work like a sandbox. They can dynamically emerge and cease to exist, objects can be only in one world or in more worlds at the same time.

All of this could be simulated by using the objects, that would store other objects, but we would need to do many things manually. Korz offers this as a built-in and it's supported right at the level of a virtual machine.

You can find a better description in the papers:

Protip: If you don't know how to get the papers, use scihub (Google will help you).

Unfortunately, that is all that I can say about Korz. As far as I know, it is not an open source software and its author didn't talk about it too much, and he also didn't react to questions in the conference:

The Metaphysics

"Metaphysics" might be an exaggeration but I wanted to express the context, possible potential and vision of Self, which I partially picked up from the historical materials, and partially dreamed up.


Few years back while reading through complete archives of Self conference I found something, that still keeps on lighting up my imagination. It's a proof of concept of a system for working with information and visualization of programs called Tarraingim, Tgim in short. It was created by James "kjx" Noble as his academic work.

The system made it possible to display and browse objects the way we are used to browsing files, using icons and various visualizations.

Of course, the images above do have their limitations and the original intention was more in the direction of working with programming languages. Yet, I cannot stop wondering and imagining how visualizations like this could be used for various information representations and personal wikis.

As Alan Kay said:

Point of view is worth 80 IQ points

I think that Tarraingim was a fascinating experiment on the topic of the environment, that gives you many prepared points of view.

Engelbart's MOAD

It has been 50 years since, probably, the most influencing computer presentation of all time: so-called Mother of all demos by Douglas Engelbart.

More information here:

If you missed this demo, I can only recommend watching it:

For many people, Engelbart's demo is a visionary thing. They often praise it as a precursor of modern computer technology, which predicted many modern technologies, such as graphic user interface, the Internet, interactive video calls and other conveniences of our network age. It was the first time a computer mouse was used!

At first glance, it should be a phenomenal success. After all, who can predict and define the future as well as Engelbart did?

But for Engelbart it was quite a disappointment. A disappointment, which can still be felt around lisp and Smalltalk communities. You can hear about it from Alan Kay, or Bret Victor;

In short only a less important part of his vision got fulfilled. The original vision was about acceleration of human progress through attempts at empowering the human intelligence.

This should have been achieved by using computers as assistants, as Vannevar Bush defined it in his famous paper As We May Think. He wanted to use the strategy of boostraping; process improvements for process improvements. You can find the specific details in his work Augmenting Human Intellect: A Conceptual Framework.

He never intended to create a user interface for masses, so people could intuitively use computers and not know or understand anything about them, as it was popularized by Apple. On the contrary! His lifelong effort was concentrated on interconnecting people and computers in the tightest possible manner.

If you allow me to use a rough analogy, then what he was trying to achieve was similar to mathematics and education in mathematics. A system, which he was creating, was supposed to be like math for a person, who is trying to build a bridge. His "conceptual framework" was supposed to give people a way of thinking and an ability to use a computer as an extension of their minds. That is in sharp contrast to how we use computers today, which is mostly a medium that allows us to record, edit, search and broadcast our digital creations.

His idea was that a person trying to do intellectual work would be able to program the computer and instruct it as effectively as possible by creating a closed loop with it so that he could no longer tell where the person ends and the machine begins.

What I mean by this is possible to understand if you have ever used a program so much, that you no longer perceived its controls and had a feeling, that you are communicating with a computer only using your thoughts. This kind of symbiosis can be seen when you look at the programmers, who often customize their editors and use them on a day to day basis so that they are highly effective and can use all kinds of text transformations that are unavailable to untrained people.

Or a person who is modelling a 3D object in a graphical editor and after a while no longer thinks about the controls of the program, only about the modelling. Players also often forget that they are pressing wasd and instead feel like they are inside the game.

Engelbart wanted to create a system for working with computers and information in general, in this manner. That's why he created his NLS (oN-Line System), and that is why his demo is still so amazing even today. Most of the programs of today fall behind because they are limited by paradigms of graphic interface and the effort to make them as intuitive as possible. If some program actually achieves usability envisioned by Engelbart, then it's usually a specialized matter. You can't use CAD, with which you design houses, to write a document or create your own personal information database.

If you think about it, work with information was, apart from its presentation, reduced only to office packages and writing notes in wiki. You can't, for example, download all your ratings from IMDB, correlate them with your friends and recommend them films they may like, without being a programmer.


You may be wondering how Self is related to all of this. Personally, I hope that it is clearly visible from the already published articles that I consider Self to be the closest thing to the Engelbart's vision from everything that I am aware of.

Just think about it:

  1. An object-oriented graphical interface that can be assembled and disassembled in a relatively intuitive way to quickly construct user programs.
  1. Objects as an underlying structure for working with information.
  1. Interconnection of the programming language with the entire environment, so there is no clear separation between where one ends and the other begins.
  1. The resulting addressability of all items simply through messages to the objects.

Of course, Self is in a very desolate state. Some of the ideas were just outlined, others were put into practice sometime in 1992 and no one has touched them since. Just have a look at this short preview of a demo snapshot:

It's hard to not compare it to the possibilities of Engelbart's NLS.

I don't want to claim that Self is what Engelbart envisioned. In my opinion, however, many of his thoughts went the same way*. If it had been finished properly, then we would have an infinitely programmable environment where everything is an addressable and callable object. A graphical interface environment with a paradigm that allows everyone to create their own graphical applications. A system that, with a little effort, can be used as an extension of one's mind.

I think it's worth thinking about.

* See my question in the conference about the inspiration for Self:

Concluding remarks

That's all I can say about Self. A small part of a facet of a polyhedral crystal, reflection of sparks of ideas, words about the thought model in motion.

Even if it didn't change my point of view on the world of programming languages, interactive environments, and graphical programmable systems, it still completely changed my thinking about reflection. And that is something, which shows through everything that I have been lately thinking about and what I have been working on.

Things created in a computer can have any shape. And somehow, as humanity, we have made a collective decision, probably totally unconsciously and certainly wrongly, that they won't be as dynamic as they could. Self showed that there is a possibility for everything to work differently.

I'm a witness to Self still hiding a lot of magic, which hasn't been seen by many. Secrets visualized by the mind. It's up to you to reach out and look at them.

Relevant discussions

Become a Patron