The ICFP/SPLASH papers are now starting to find their way to HN.
This was a HUGE combined programming conference with several competing tracks over 7 days. You can find the program here ^1 (you can often find a link to the abstract or full paper if you click on it)
Streams from the sessions will also show up here^2 (you’ll need to match the day and room and ff to the time it appeared)
I had a chance to skim over the paper, and I'm very inspired; I'm looking forward to reading it in depth and considering its lessons while working on my side project. For about a decade, I've been dreaming about building a modern operating system that is highly malleable and encourages component-based software design, and I've collected many thoughts and done a lot of reading. I've been inspired by many projects, including the Smalltalk-80 environment, Lisp machine environments (especially Symbolics Genera), various 1990s Apple projects (Dylan, the Bauhaus operating system designed for the Newton and written in Lisp, OpenDoc), Plan 9, Alan Kay's Viewpoints Research Institute's work on STEPS (https://news.ycombinator.com/item?id=11686325), and Stephen Kell's work on exploring the connections between Unix, Plan 9, and Smalltalk.
Unfortunately I haven't made any progress beyond design notes written in paper notebooks; I've got swamped with work (though now I have more free time since becoming a community college professor last year; I have summers off now!). I've also changed my design plans from basing off of Plan 9 to building a new exokernel in a language like Rust, adapting NetBSD's rump kernel for driver support, and using a single-address space design similar to Opal (https://dl.acm.org/doi/10.1145/195792.195795), though this isn't reflected in the MallowOS webpage yet.
Another thought has come to mind: not too long ago there was a discussion here about Etoile (http://etoileos.com/), a project from the late 2000s-early 2010s that attempted to build a GNUstep-based desktop environment. What made Etoile unique is its embrace of the Smalltalk inspirations of Objective-C. Imagine a new project that took Smalltalk inspiration one step further by adapting the ideas of this paper, fully integrating Smalltalk with the Unix framework.
Sounds interesting; I would like to see more OSes built out of passion. Just curious about design choices (I don't mean to come off as aggressive below):
> from basing off of Plan 9 to building a new exokernel in a language like Rust
This seems like a big change. Won't the driver support and infrastructure be even more of a hassle? And why an exokernel in particular?
> using a single-address space design similar to Opal
Why?
I like the emphasis on composability and user control. I think, more and more, people are realizing the necessity to seek out OS designs different than the mainstream offerings'. Can't let Linux be the final stage of OS evolution!
The rest of the paper seems to be about how to make that, or its moral equivalent, not just work but work efficiently.
When I implemented this idea in 02002 (in shell scripts) the clumsiest thing was lifetime management of the objects, as Jakubovic anticipates in the paper. I had thought that I put symlinks to the method scripts directly into each object directory, making it a prototype-based OO system, but no, it actually implemented walking a prototype chain, just as Jakubovic's proposed system walks a superclass chain. And, just as Jakubovic did, I passed the receiver's pathname as the first argument to the method executable, passed arguments on the command line, and returned results on stdout. I called my version "shoo"⁴ but it wasn't original to me, inspired by Martin Hinsch's "woosh"⁵:
> shoo makes your filesystem and shell into a prototype-based
object-oriented programming environment with dynamic method binding,
transparent persistence (but terrible memory management!), multiple
inheritance, and local-network distributed objects (if you have NFS,
and only the state is distributed --- not the computation).
> Unfortunately, it still doesn't make the shell into a decent
general-purpose programming language.
shoo was painfully slow. The `testscript` in the package takes 4.5 seconds on my cellphone in Termux, and all it does is instantiate two rectangular points, two polar points, and three other objects, and call some methods on them. I'm pleased to see that it does at least pass, but it might be reaching 10 or 20 message sends per second.
In shoo, the pathname at which to create the new object was an argument to the new and derive methods, as in Tk. I think something like this is probably a good idea if you want to use this approach for something; otherwise it would be very difficult to clean up. It also makes the shell script quite a bit more readable because you don't have to capture return values so often:
oo newobj pr
oo basicobject derive thirdobj
oo thirdobj defprop acting "What's my motivation?"
oo thirdobj acting
oo newobj derivefrom thirdobj
oo newobj acting
oo anotherobj die
oo newobj die
As in Self, adding a property to an object (such as `acting`) adds corresponding getters and setters. The `die` method was one I defined in basicobject to rm -rf the receiver, due to the lack of any GC.
Other code did have to use the rather clumsy bash syntax for capturing output. I didn't attempt to make numbers and strings into objects as Jakubovic wants to; here's the method rectpointclass/r, which calls the x and y accessors:
#!/bin/bash -e
# generate radius for a rectangular point.
x="$(oo "$1" x)"
y="$(oo "$1" y)"
echo "e(l($x * $x + $y * $y)/2)" | bc -l
Jakubovic mentions that creating a million Unix processes will cause "bad things to happen" but even on my laptop creating and destroying a million processes only takes about a minute (httpdito² can serve 20000 hits per second, creating all the children from a single core; C programs are much slower³, about 7000 fork/exit/waits per second, presumably because they map more pages) and I think you could do it in a second with AWS Lambda. Possibly you don't want them all to exist at once, but of course the original Smalltalk systems couldn't do that either—their...
I think it worthwhile pointing out Xerox PARC efforts to bring their programming environments to UNIX, as they slowly lost the market they could have had.
"UNIX Needs A True Integrated Environment: .CASE Closed"
NeXTSTEP and macOS are only thing left from those ideas in modern systems, combing UNIX and Xerox PARC worlds.
While there are some of those ideas influenced Windows, via Objective-C => Java => .NET, and Android is what Inferno/Limbo could have been, it is not quite the same as those early ideas how computing should be like.
I recall someone, maybe Alan Kay, saying that object oriented programming was a bit of a misnomer. A better description of what they were getting at was message oriented programming, replacing the notion of blocking function calls with message passing. Objects were just a way of grouping state with functions and were less significant.
14 comments
[ 4.3 ms ] story [ 60.3 ms ] threadThis was a HUGE combined programming conference with several competing tracks over 7 days. You can find the program here ^1 (you can often find a link to the abstract or full paper if you click on it)
Streams from the sessions will also show up here^2 (you’ll need to match the day and room and ff to the time it appeared)
^1: https://conf.researchr.org/program/icfp-splash-2025/program-...?
^2: https://youtube.com/playlist?list=PLyrlk8Xaylp5ihrTVeOSaylaB...
During the COVID-19 pandemic I collected my thoughts on my blog (https://mmcthrow-musings.blogspot.com/2020/04/a-proposal-for...) and on a site that I decided to dub MallowOS (https://mallowos.com/), paying homage to Apple's Pink/Taligent project and Google's Fuchsia project.
Unfortunately I haven't made any progress beyond design notes written in paper notebooks; I've got swamped with work (though now I have more free time since becoming a community college professor last year; I have summers off now!). I've also changed my design plans from basing off of Plan 9 to building a new exokernel in a language like Rust, adapting NetBSD's rump kernel for driver support, and using a single-address space design similar to Opal (https://dl.acm.org/doi/10.1145/195792.195795), though this isn't reflected in the MallowOS webpage yet.
Another thought has come to mind: not too long ago there was a discussion here about Etoile (http://etoileos.com/), a project from the late 2000s-early 2010s that attempted to build a GNUstep-based desktop environment. What made Etoile unique is its embrace of the Smalltalk inspirations of Objective-C. Imagine a new project that took Smalltalk inspiration one step further by adapting the ideas of this paper, fully integrating Smalltalk with the Unix framework.
> from basing off of Plan 9 to building a new exokernel in a language like Rust
This seems like a big change. Won't the driver support and infrastructure be even more of a hassle? And why an exokernel in particular?
> using a single-address space design similar to Opal
Why?
I like the emphasis on composability and user control. I think, more and more, people are realizing the necessity to seek out OS designs different than the mainstream offerings'. Can't let Linux be the final stage of OS evolution!
When I implemented this idea in 02002 (in shell scripts) the clumsiest thing was lifetime management of the objects, as Jakubovic anticipates in the paper. I had thought that I put symlinks to the method scripts directly into each object directory, making it a prototype-based OO system, but no, it actually implemented walking a prototype chain, just as Jakubovic's proposed system walks a superclass chain. And, just as Jakubovic did, I passed the receiver's pathname as the first argument to the method executable, passed arguments on the command line, and returned results on stdout. I called my version "shoo"⁴ but it wasn't original to me, inspired by Martin Hinsch's "woosh"⁵:
> shoo makes your filesystem and shell into a prototype-based object-oriented programming environment with dynamic method binding, transparent persistence (but terrible memory management!), multiple inheritance, and local-network distributed objects (if you have NFS, and only the state is distributed --- not the computation).
> Unfortunately, it still doesn't make the shell into a decent general-purpose programming language.
shoo was painfully slow. The `testscript` in the package takes 4.5 seconds on my cellphone in Termux, and all it does is instantiate two rectangular points, two polar points, and three other objects, and call some methods on them. I'm pleased to see that it does at least pass, but it might be reaching 10 or 20 message sends per second.
In shoo, the pathname at which to create the new object was an argument to the new and derive methods, as in Tk. I think something like this is probably a good idea if you want to use this approach for something; otherwise it would be very difficult to clean up. It also makes the shell script quite a bit more readable because you don't have to capture return values so often:
As in Self, adding a property to an object (such as `acting`) adds corresponding getters and setters. The `die` method was one I defined in basicobject to rm -rf the receiver, due to the lack of any GC.Other code did have to use the rather clumsy bash syntax for capturing output. I didn't attempt to make numbers and strings into objects as Jakubovic wants to; here's the method rectpointclass/r, which calls the x and y accessors:
Jakubovic mentions that creating a million Unix processes will cause "bad things to happen" but even on my laptop creating and destroying a million processes only takes about a minute (httpdito² can serve 20000 hits per second, creating all the children from a single core; C programs are much slower³, about 7000 fork/exit/waits per second, presumably because they map more pages) and I think you could do it in a second with AWS Lambda. Possibly you don't want them all to exist at once, but of course the original Smalltalk systems couldn't do that either—their..."UNIX Needs A True Integrated Environment: .CASE Closed"
http://www.bitsavers.org/pdf/xerox/parc/techReports/CSL-89-4...
Interlisp-D gets ported to UNIX in 1988
https://interlisp.org/history/timeline/
Cedar gets ported into UNIX in 1989
"Experiences creating a portable cedar"
https://dl.acm.org/doi/10.1145/74818.74847
NeXTSTEP and macOS are only thing left from those ideas in modern systems, combing UNIX and Xerox PARC worlds.
While there are some of those ideas influenced Windows, via Objective-C => Java => .NET, and Android is what Inferno/Limbo could have been, it is not quite the same as those early ideas how computing should be like.
Semi-related; anybody have an old NeXTcube they'd be willing to part with? I'm a student and I need it for school and things.