Aha i saw this video in a comment on another HN thread this week: https://news.ycombinator.com/item?id=49791117 Avoiding the babbling-idiot failure in a time-triggered communication system
The full talk seems to be at https://au.cloud.panopto.eu/Panopto/Pages/Viewer.aspx?id=fe0..., but with a confusing interface (text chat flying by at speed, and no actual video of Alan, though you do get a prolonged view of a whiteboard). Maybe there's another copy that exists or will show up somewhere?
Yes it's a pretty klunky interface. Easy to miss that there are multiple camera icons to the right of the time slider, and you can switch to see different feeds like the speaker or their slides. It's still kind of hit or miss with some of the speakers, but at least Alan got a chance to test things out and debug all the glitches before his talk, so he didn't end up repeatedly interrupting himself!
Here is the full list of links from the video description to other related and interesting topics.
I can highly recommend smoking a joint and watching James "Doctor Chaos" Crutchfield's "Space-Time Dynamics in Video Feedback" film, which he made at UC Santa Cruz in 1984, building on Ralph Abraham's video feedback experiments there in the 1970s:
Alvin Lucier wrote other highly interesting, if unconventional works, although similar to John Cage's 4'33", this is the one that achieved meme status as conceptual art.
Did he though? TMK Shannon did specifically not give a way to deal with noisy channels, no. He invented a way to quantify what could be sent on a noisy channel if you figure out the optimal way to do it. This is very similar to "no matter what you figure out about faster travel, you can't go faster than light in a vacuum".
Calculating the limit is easy with Shannon's theorem. Approaching it in practice is hard.
> Calculating the limit is easy with Shannon's theorem. Approaching it in practice is hard.
Many modern modulations already operate basically on Shannon's limit for a given band/SNR. Well, on raw data, the encoding almost always use some kind of error correction so the decoded bitrate is few % lower than the wire one
That’s understating the importance of the error coding. The modulation scheme is almost a side show, it’s the modern error coding algorithms (LDPC or Turbo coding) that allows you to get arbitrary close to the Shannon limit.
The way I've understood it is Shannon showed that it's possible to reliably send a signal even if you know the signal will get corrupted before arriving at the other end.
Shannon's theory is foundational to modern communication systems. You can expect to have WiFi remain functional even as other devices use the same medium. Up to a point, the Shannon limit in other words.
My favorite part was how Google's speech to text transcriptions censored the word "fuck" to "[__]", adding another layer of censorship noise and interpretation to the mix.
And how the conference's real time speech to text transcription would occasionally lapse into Danish, and say things like "We will eat your hands".
It would have been kind of great to see an OOP language with Alan's design, but with a better syntax. I dislike smalltalk syntax. Barely anyone uses smalltalk today.
Even then, we'd also have an OOP language to be really really fast. Otherwise people will just use C.
Java itself is too verbose and has a rather boring OOP model.
How about Elixir and Erlang? They do pretty much exactly what Kay preaches.
Interestingly, the OO model that Wirth and Gutknecht implemented in the Oberon system corresponds better to Kay's message-based vision than Smalltalk-80. Wirth arrived here not by trying to emulate biology, but by trying to avoid the V-Table.
Java implemented the Simula 67 object model according to a 2017 Gosling lecture (as did early C++ and Smalltalk-80 to a significant degree).
> Interestingly, the OO model that Wirth and Gutknecht implemented in the Oberon system corresponds better to Kay's message-based vision than Smalltalk-80. Wirth arrived here not by trying to emulate biology, but by trying to avoid the V-Table.
That's interesting! what did they do that corresponded better?
In contrast to the "usual" (i.e. Simula 67 based) OO approach, Wirth avoided virtual methods in his Oberon language, but instead used type extension (i.e. inheritance) to declare specialized message records (as the replacement to variant records of Pascal and Modula) which were handled by procedure-typed fields of record variables (i.e. objects) using polymorphic dispatch based on the dynamic message type. The intention was not to "correspond better" to Kay's vision (Wirth likely didn't know Kay nor was he interested in his visions), but he arrived at a similar design from a different motivation. And the analogy only works when considering what Kay and team actually implemented (i.e. "message delivery" - a record in case of Oberon, a stream of tokens in case of Smalltalk-72 - via synchronous procedure calls). Smalltalk-80 instead implemented compiled virtual methods and table-based polymorphic dispatch like Simula 67, just with a dynamic language.
Self took the path of removing things instead of changing the syntax. It kept Smalltalk's keyword message syntax, made even smaller (no assignment syntax, variables are just slots you send messages to), and took away the classes. Only objects remain, and they inherit directly from other objects. Then Randy Smith and John Maloney gave it a visual syntax: in the Self environment you program by direct manipulation of live objects, opening outliners and editing their slots, so the environment is the syntax and the text is mostly incidental.
Your speed point is answered by the same work. Craig Chambers, David Ungar and Urs Holzle's compiler for Self (customization, inline caches, adaptive recompilation) was so fast that the technology went on to HotSpot and V8, and those ideas are why Java and JavaScript are fast today. Removing the classes made the language simpler, and the simpler language turned out to be easier to make fast.
Then David Ungar, Harold Ossher and Doug Kimelman at IBM took the next thing away. Korz removes the objects and leaves the slots. A program is a flat sea of slots that belong to nothing. Each slot has a guard on named dimensions, and a message is sent in a context of dimension:coordinate bindings, mostly carried implicitly down the call chain the way "this" is in OO languages. The receiver is demoted to one ordinary dimension (rcvr) among any number, dispatch is symmetric over the whole context, the most specific matching slot runs, and a tie is an error.
The syntax is the least interesting part. The prototype was an interpreter written in Self, and the paper's examples look roughly like JavaScript with guards in front:
The semantics are the interesting part. The second pop is more specific, so it wins whenever the context says assertions: true. main() turns assertions on, and not one line of code in between mentions them: the binding flows down implicitly to every send underneath. You've added a new dimension of variation to a running program without touching anything between the top and the bottom. No layers, no aspects, no Visitor pattern.
And "object" doesn't disappear, it becomes subjective. Group the slots by rcvr and you see ordinary objects. Group them by assertions and you see the checking layer. Group them by user and you see one person's view of the whole system. Same sea of slots, different cuts, and no cut is the privileged one. The name comes from Korzybski: the map is not the territory.
Here's some stuff about applying Korz to cellular automata and adventure game parsers and simulators like Zork (which is only coincidentally an anagram for Korz, David Ungar assured me).
I've been applying the ideas from Self to a file system based object system for LLM orchestrated simulations, which works quite well. Then David Ungar told me about Korz, which totally blew my mind and caused me to rethink a lot of things. But it's beautifully backwards compatible with what I've been doing with Self.
Korz is "multi dimensional", where functional programming is zero dimensional, and object oriented programming is one dimensional (the implicit "receiver" object parameter, usually spelled self, this, or recr), and both are special cases 0 and 1 of multi dimensional Korz. Korz can dispatch on any number of parameters, none of them are special like "self" or "this", and you can have as many as you like, then slots have guards on them to decide which one is the most specific to dispatch to. So Self object graphs are just Korz object graphs that only happen to use one dimension. The effect is that objects are "subjective" and dynamically assemble based on how you're looking at them (coordinataes of the dimensions). So in the case of single dispatch to "self" everything looks like an object.
So you don't need things like the visitor pattern, which is just a kludge for dealing with the fact that you can only dispatch on one parameter.
Multiple dispatch is a feature some object systems like Common Lisp's CLOS/MOP support, but Korz takes it all the way and doesn't have a special case for "self/this/rcvr".
The Finest Object System You’ve Never Heard Of:
The Common Lisp Object System is the finest object system in existence, and I bet you’ve never even heard of it.
This place being well-known now for the prohibition on "shallow dismissals", I think it'd be great if we brought back the rule against submissions that are merely "shallowly interesting" (which is frankly something that this, er... "performance"* doesn't even qualify as):
* hard to read this characterization and see it as anything other than the product of unvarnished, I-want-to-believe (that Emperor is wearing magnificent robes) hero worship
Here is the full list of links from the video description to other related and interesting topics.
I can highly recommend smoking a joint and watching James "Doctor Chaos" Crutchfield's "Space-Time Dynamics in Video Feedback" film, which he made at UC Santa Cruz in 1984, building on Ralph Abraham's video feedback experiments there in the 1970s:
https://www.youtube.com/watch?v=B4Kn3djJMCE
https://en.wikipedia.org/wiki/James_P._Crutchfield
https://en.wikipedia.org/wiki/Ralph_Abraham_(mathematician)
Kristen Nygaard 100 Years, Celebration Symposium (Aarhus University, Aug 27 2026):
https://cs.au.dk/nygaard100years/celebration
Entire Nygaard Symposium Recording (Alan Kay's talk begins at 3:27:49):
https://au.cloud.panopto.eu/Panopto/Pages/Viewer.aspx?id=fe0...
Alan Kay:
https://en.wikipedia.org/wiki/Alan_Kay
Claude Shannon:
https://en.wikipedia.org/wiki/Claude_Shannon
Information Theory:
https://en.wikipedia.org/wiki/Information_theory
Noisy-Channel Coding Theorem:
https://en.wikipedia.org/wiki/Noisy-channel_coding_theorem
Audio Feedback:
https://en.wikipedia.org/wiki/Audio_feedback
Video Feedback:
https://en.wikipedia.org/wiki/Video_feedback
Live Looping: The History And The Practice, by Stephen Garza:
http://computermusic2008.wikidot.com/live-looping:history-an...
I Am Sitting in a Room:
https://en.wikipedia.org/wiki/I_Am_Sitting_in_a_Room
Alvin Lucier on "I am sitting in a room":
https://www.youtube.com/watch?v=v9XJWBZBzq4
Calculating the limit is easy with Shannon's theorem. Approaching it in practice is hard.
Many modern modulations already operate basically on Shannon's limit for a given band/SNR. Well, on raw data, the encoding almost always use some kind of error correction so the decoded bitrate is few % lower than the wire one
Shannon's theory is foundational to modern communication systems. You can expect to have WiFi remain functional even as other devices use the same medium. Up to a point, the Shannon limit in other words.
Hopefully Don won't mind!
And how the conference's real time speech to text transcription would occasionally lapse into Danish, and say things like "We will eat your hands".
Even then, we'd also have an OOP language to be really really fast. Otherwise people will just use C.
Java itself is too verbose and has a rather boring OOP model.
Interestingly, the OO model that Wirth and Gutknecht implemented in the Oberon system corresponds better to Kay's message-based vision than Smalltalk-80. Wirth arrived here not by trying to emulate biology, but by trying to avoid the V-Table.
Java implemented the Simula 67 object model according to a 2017 Gosling lecture (as did early C++ and Smalltalk-80 to a significant degree).
That's interesting! what did they do that corresponded better?
Your speed point is answered by the same work. Craig Chambers, David Ungar and Urs Holzle's compiler for Self (customization, inline caches, adaptive recompilation) was so fast that the technology went on to HotSpot and V8, and those ideas are why Java and JavaScript are fast today. Removing the classes made the language simpler, and the simpler language turned out to be easier to make fast.
Self:
https://selflanguage.org/
Then David Ungar, Harold Ossher and Doug Kimelman at IBM took the next thing away. Korz removes the objects and leaves the slots. A program is a flat sea of slots that belong to nothing. Each slot has a guard on named dimensions, and a message is sent in a context of dimension:coordinate bindings, mostly carried implicitly down the call chain the way "this" is in OO languages. The receiver is demoted to one ordinary dimension (rcvr) among any number, dispatch is symmetric over the whole context, the most specific matching slot runs, and a tie is an error.
The syntax is the least interesting part. The prototype was an interpreter written in Self, and the paper's examples look roughly like JavaScript with guards in front:
The semantics are the interesting part. The second pop is more specific, so it wins whenever the context says assertions: true. main() turns assertions on, and not one line of code in between mentions them: the binding flows down implicitly to every send underneath. You've added a new dimension of variation to a running program without touching anything between the top and the bottom. No layers, no aspects, no Visitor pattern.And "object" doesn't disappear, it becomes subjective. Group the slots by rcvr and you see ordinary objects. Group them by assertions and you see the checking layer. Group them by user and you see one person's view of the whole system. Same sea of slots, different cuts, and no cut is the privileged one. The name comes from Korzybski: the map is not the territory.
Korz: Simple, Symmetric, Subjective, Context-Oriented Programming (Onward! 2014):
https://dl.acm.org/doi/10.1145/2661136.2661147
Here's some stuff about applying Korz to cellular automata and adventure game parsers and simulators like Zork (which is only coincidentally an anagram for Korz, David Ungar assured me).
https://github.com/SimHacker/moollm/tree/main/designs/korz
I've been applying the ideas from Self to a file system based object system for LLM orchestrated simulations, which works quite well. Then David Ungar told me about Korz, which totally blew my mind and caused me to rethink a lot of things. But it's beautifully backwards compatible with what I've been doing with Self.
Korz is "multi dimensional", where functional programming is zero dimensional, and object oriented programming is one dimensional (the implicit "receiver" object parameter, usually spelled self, this, or recr), and both are special cases 0 and 1 of multi dimensional Korz. Korz can dispatch on any number of parameters, none of them are special like "self" or "this", and you can have as many as you like, then slots have guards on them to decide which one is the most specific to dispatch to. So Self object graphs are just Korz object graphs that only happen to use one dimension. The effect is that objects are "subjective" and dynamically assemble based on how you're looking at them (coordinataes of the dimensions). So in the case of single dispatch to "self" everything looks like an object.
So you don't need things like the visitor pattern, which is just a kludge for dealing with the fact that you can only dispatch on one parameter.
Multiple dispatch is a feature some object systems like Common Lisp's CLOS/MOP support, but Korz takes it all the way and doesn't have a special case for "self/this/rcvr".
https://en.wikipedia.org/wiki/Multiple_dispatch
The Finest Object System You’ve Never Heard Of: The Common Lisp Object System is the finest object system in existence, and I bet you’ve never even heard of it.
https://mendhekar.medium.com/the-finest-object-system-youve-...
Recently I've been thinking about how to apply Korz to LLM driven simulations, which I'm calling "Korz'".
https://github.com/SimHacker/moollm/tree/main/designs/korz/k...
https://crystal-lang.org/
<https://hn.algolia.com/?q=%22shallowly+interesting%22>
* hard to read this characterization and see it as anything other than the product of unvarnished, I-want-to-believe (that Emperor is wearing magnificent robes) hero worship