DonHopkins

Thanks! I'm in the process of bailing from Medium, and I'm moving my stuff to a reimplemention of HyperTIES, the hypermedia browser I developed for NeWS in 1987-1990 at the University of Maryland Human Computer Interaction Lab, and I'm dogfooding it to publish all my other stuff:

https://hyperties.org

Ostensibly the site is about HyperTIES itself, but I'm publishing other stuff there too like a PDP-7 emulator!

https://hyperties.org/databases/pixie/pixie-live/

Here's a part of the demo I was giving at EduCom in October 1988 at the Sun booth on the trade show floor, across from the NeXT booth, where Steve Jobs and Bill Joy came by. Because he had shaved his beard, I didn't realize it was Bill Joy when I was showing him a demo of his head popping up! He took it pretty well though, better than Jobs.

https://hyperties.org/databases/playground/sun-founders-big-...

Here's a paper looking back at HyperTIES:

https://hyperties.org/databases/hyperties/a-look-back/

Check out this chunky industrial Bakelite switch with a resonant thunking spring clicking action that you have to overshoot each of the four rotations by 45 degrees before it clicks. It feels so good, it's nice to just turn around and around just for pure audio and kinesthetic pleasure. So much better than a Tesla iPad control. (Never mind the gorilla!)

https://www.youtube.com/shorts/o_n5W2I2p_M

It's from the Amsterdam Bakelite Collection, founded/curated by Reindert Groot. It isn't actually a museum you can visit at this moment, but it's a huge beautiful collection, with lots of interesting photos and articles and newsletters online, and parts of it surface in museums around the world from time to time.

http://www.amsterdambakelitecollection.com/

There are some beautiful photos in the newsletters, like the colossal steel 1500 Kg two-part injection mold, and the restored SAAL Soft SPEAKER with the Bakelite Bell:

http://www.amsterdambakelitecollection.com/newsletter202411/...

Other interesting Bakelite links from previous Hacker News discussions:

1956 Philips 353A Bakelite Vacuum Tube Radio Repair & Restoration

https://retrorepairsandrefurbs.com/2022/09/06/1956-philips-3...

Bakelite to the Future - 1950s rotary phone ESP32 bluetooth headset

https://blog.waleson.com/2024/10/bakelite-to-future-1950s-ro...

I filled out a form and pressed the SUBMIT button, but it made ME submit.

We had a GT40 at the University of Maryland Vax lab, which we would play Lunar Lander on when the Vax was down.

Scott Swazey gave a great talk at VCF West 2024 about restoring a GT40 and getting Lunar Lander running on it again, and it touches on everything in this thread: core memory, bootloaders, front panel single stepping, light pens, and retyping lost ROMs from listings.

https://www.youtube.com/watch?v=G6h6r6MGWyI

Your point about core surviving power cycles is part of the game (19:44): "because the game has core memory which is nonvolatile, so when I turn off the machine it saves everything, all of the carcasses from the crash landers of all the failed attempts are scattered across the screen. And interestingly enough, if you leave the game running long enough the game will crash, because there's no more memory left for any more carcasses."

https://www.youtube.com/watch?v=G6h6r6MGWyI&t=1184s

It was also arguably the first Easter egg, in 1973 (20:17). Land next to the McDonald's and the astronaut walks over and says "I'll take two cheeseburgers and a Big Mac to go." At a show he crashed into it instead and got "You have destroyed the only McDonald's on the moon", and since core remembers everything, nobody else could find it after that (21:13).

https://www.youtube.com/watch?v=G6h6r6MGWyI&t=1273s

The GT40 came up in a bootloader and pulled programs down the serial line, so no toggling, but debugging it was pure front panel. Hitting line feed crashed the PDP-11, so he single-stepped through the bootloader with a diagnostic card, down to a byte compare of the high byte, which goes through a shift, and found a dead 74194 4-bit shifter (15:50).

A PROM on one of the boards had failed, and no binary of it survived anywhere, so they typed its 256 entries back in from the listings (13:46). His rule number one is "don't trust anybody": he double-checked his friend's careful transcription and found two transposed digits that "would have created a bug so subtle that it would have taken us months to find it" (14:31). The same rule caught the downloaded diagnostics, which had a stray "!" and a newline inserted that made the loader abort (17:15). And on Bitsavers: "we could not have restored it without it" (13:10).

https://www.youtube.com/watch?v=G6h6r6MGWyI&t=826s

Other highlights: Atari's 1979 Lunar Lander turns out to be a direct copy of the GT40's vector generator, binary rate multipliers and all, with a 6502, ROM and static RAM swapped in for the PDP-11 and its expensive core (5:11). At VCF Midwest the wall power sagged to 90 volts, so he ran it off his camping battery (23:39). And he showed it next to the PDP-11/45 that animated the Death Star trench briefing in Star Wars, with a dueling light pen battle between the two (24:46).

I've been doing the same kind of thing without the soldering iron: bringing Heinz Lemke's 1972 PIXIE/SYMELEC light pen system for the PDP-7 and Type 340 back to life in a browser emulator, from a scanned listing, since no tape survives. Then DEC's own 1964 370 Light Pen Diagnostic, transcribed from a scan that skips from page 5 to page 7, so page 6 had to be rebuilt from how the surviving pages use each of its symbols.

Scott's rule number one turned out to be mine too. Every bug falls into one of three kinds: ours (the emulator got it wrong), the transcription's (the listing was misread off the scan), and 1972's (the listing itself is wrong, and the emulator should faithfully reproduce the mistake). The first one was a truncated literal pool. The conversion stopped at word 11741, so every (JMP INT literal read as 0, and the machine initialized itself into a wall. So far, every bug had its answer on paper before anyone went looking. The emulator's job is to run the listing until it disagrees with itself, and then to show where.

Bug Journal:

https://github.com/SimHacker/WillWrightShowForFood/blob/main...

370 Light Pen Diagnostic (DEC-4-45-M, 7-78-M):

https://github.com/SimHacker/WillWrightShowForFood/blob/main...

1972 PIXIE PDP-7 Assembler Listings:

https://github.com/SimHacker/WillWrightShowForFood/tree/main...

In 1972 the PDP-7 was the small one. It hung off Cambridge's Titan (an Atlas 2 that filled a room and ran the university) as a satellite, phoning home over Neil Wiseman's custom link to store and retrieve drawings in the Titan filestore.

The emulator inverts that: tiny-titan is the whole of Titan, as much of it as PIXIE ever saw, in one TypeScript file, serving its emulated satellite from inside a browser tab. It implements only what the one surviving caller ever dialed, and SYMELEC's unmodified link code runs against it.

Tiny Titan:

https://github.com/SimHacker/WillWrightShowForFood/blob/main...

tiny-titan.ts:

https://github.com/SimHacker/WillWrightShowForFood/blob/main...

Flight of the PIXIE - Yuja Wang:

https://www.youtube.com/watch?v=jDrqR9XssJI

PIXIE Live in PDP-7 Emulator with 340 Vector Display Simulator:

https://hyperties.org/databases/pixie/pixie-live/

Press the "DEMO" button and it will make a goofy child's drawing with the virtual light pen. I plan to ask Claude to make a new demo by trying to draw a pelican riding a bicycle.

Enable the MEMORY panel's "SOURCE" + "FOLLOW PC" mode, then slow the emulator down with the slider, to see the PDP-7 assembly source code it's executing (from the OCR of the scan of 128 pages of line printer output).

You can also pick "LIGHT PEN TEST (1964)" from the menu and press "DEMO", or pick "DUEL (1968)" and play spacewar for two, DECUS 7-40, loaded from paper tape through the RIM loader, the PDP-7's version of your bootstrap.

And I made a non-graphical "HILO (2026)" number guessing game and a "LUNAR LANDER (2026)" game to test out the TTY simulator. The lander is in the spirit of the turn-based original Scott describes (1:52), before the GT40 made it real time: "YOU ARE 500 FEET UP, FALLING AT 50 FT/S, WITH 60 UNITS OF FUEL."

Lander README:

https://github.com/SimHacker/WillWrightShowForFood/blob/main...

lander.s:

https://github.com/SimHacker/WillWrightShowForFood/blob/main...

PDP-7 Unix is coming soon. Warren Toomey, Phil Budne, Tom Everett, Sebastian Rasmussen, Robert Swierczek and friends did this kind of restoration on a much bigger scale with the pdp7-unix project. Starting in 2016 they typed in Ken Thompson's 1969-70 PDP-7 Unix from Norman Wilson's scans of the only surviving printouts, wrote a cross-assembler (as7) and a user-mode simulator, and got the kernel booting to a shell with a working filesystem.

In 2019 a second notebook of missing sources turned up and was scanned and typed in too, and in January 2020 it ran on a real PDP-7 at the Living Computer Museum. It even has moo, the bulls-and-cows number guessing game, a 1970 cousin of my HILO.

PDP-7 Unix:

https://github.com/DoctorWkt/pdp7-unix

Recovered Unix documents:

http://www.tuhs.org/Archive/Distributions/Research/McIlroy_v...

Their as7 was the precedent for my own assembler, which can run in the browser and produce symbol tables and source maps, the way a TypeScript to JavaScript compiler does. That's what drives the Memory panel's Source + Follow PC mode, and it's the groundwork for live coding:

https://github.com/SimHacker/WillWrightShowForFood/blob/main...

To run Unix, the cabinet needs what its SIMH script asks for: 8K with EAE, the teletype, the clock, and the RB09 fixed-head disk. It loads boot.rim, and the bootstrap reads the system from disk. So the new part is porting SIMH's RB09.

B comes with it: the interpreter (bi.s) and loader (bl.s) survive in the scans, and Robert Swierczek rebuilt the missing compiler in 2016. There's no C on the PDP-7. C came later on the PDP-11, and B was Thompson's cut-down BCPL.

The plan is in the cabinet README:

https://github.com/SimHacker/WillWrightShowForFood/blob/main...

And a couple days ago Mitch Bradley wrote a PDP-7 FORTH for it, including a Turtle Graphics package, which I'll integrate soon too! That's the other half of live coding. My assembler is TypeScript running on the emulator host, but Forth will run on the PDP-7 itself: you type new definitions at the emulated teletype, and the turtle draws them on the 340, interactively, in a language living inside the machine.

B compiles to threaded code too, so the cabinet will have two threaded interpreters, 1970 and 2026, running side by side!

Fittingly for a thread about whether the ENIAC had a BIOS: Mitch is the one who wrote Open Firmware, the Forth-based boot firmware in Sun workstations, PowerPC Macs, and the OLPC XO. So the PDP-7 is getting its Forth from the same man who invented Open Firmware to put Forth in the BIOS.

Mitch Bradley's PDP-7 Forth:

https://github.com/MitchBradley/pdp7forth/tree/main

PDP-7 Forth — Design Notes:

https://github.com/MitchBradley/pdp7forth/blob/main/DESIGN.m...

turtle.fs: Turtle Graphics for 340 vector graphics processor in FORTH (which works by assembling 340 display IOT opcodes):

https://github.com/MitchBradley/pdp7forth/blob/main/lib/turt...

Mitch Bradley singing the Open Firmware Song

https://www.youtube.com/watch?v=b8Wyvb9GotM

Mitch Bradley shows and explains Open Firmware

https://www.youtube.com/watch?v=KvxxAeuhPp0

Mitch's threading technique is a new one, as far as we can tell, small fast and elegant on the PDP-7. NEXT is three instructions, and the core of it is XCT I 10: it bumps an auto-index register and executes the thread cell it points at, so every cell in a compiled definition is itself a PDP-7 instruction, and its opcode is its type. CAL enters a colon word, JMP runs a primitive, and LAC or LAW pushes a constant or variable.

That makes location 10 a second program counter, running a virtual machine whose instruction set is the PDP-7's own. It doesn't fit Anton Ertl's threading taxonomy. For publication, "XCT Threading". For the T-shirt, "Indirectly Direct Threading".

PDP-7 Forth XCT Threading:

https://github.com/SimHacker/WillWrightShowForFood/blob/main...

Kristen Nygaard would have turned 100 last month, so here's a history of object-oriented programming as a series of subtractions, each one taking away something the previous generation thought was essential.

Nygaard and Ole-Johan Dahl built Simula at the Norwegian Computing Center to simulate things like ships moving through harbors and customers waiting in queues. Simula I (1962-65) was a simulation language. Simula 67 generalized it and gave us nearly the whole kit: classes, objects, subclasses, virtual procedures (dynamic dispatch), and coroutines, so each object could run its own little process. They shared the Turing Award for it in 2001. Nygaard went on to design BETA with Ole Lehrmann Madsen and Birger Møller-Pedersen, and to pioneer participatory design, working with trade unions on how workers should have a say in the systems imposed on them. He never thought of programming as separate from the people it was for.

https://cs.au.dk/nygaard100years/celebration

https://news.ycombinator.com/item?id=49850612

>Speaking of vtables, at Kristen Nygaard's 100-year birthday celebration Bjarne Stroustrup also gave a fascinating talk after Alan Kay's, and they had some spicy back-and-forth discussion afterwards! Both call themselves Nygaard's heirs, and it was a delightful and respectful interplay between very different world views.

>Kay came to Simula as a reader, turned it into Smalltalk, and later knew Nygaard and Dahl as colleagues. Stroustrup was taught by Nygaard in person, as a student at Aarhus, and then used Simula for his PhD.

>Roughly: Stroustrup said he never took much from Smalltalk. What he took from Simula was the static part, compile-time guarantees and a direct map to hardware with zero-overhead abstraction, and C++ was never meant to be just an object-oriented language, since not everything is a class hierarchy or a virtual function. Kay argued that late binding pays for itself because the human is the slow part of an interactive system, and that static typing is a good idea applied prematurely. They agreed that the real job of an operating system or the internet is never to crash and never lose anything, and came at it from opposite ends: Stroustrup is working on guarantees against dangling pointers, out of range access, and uninitialized memory in C++, while Kay pointed out that Smalltalk protected every object dynamically.

Simula inspired two very different children.

Alan Kay saw Simula I and Sketchpad in the same week in grad school at Utah in 1966, and it gave him the idea that everything could be like a little computer: protected, self-contained processes that only communicate by sending messages. When someone asked what he was working on, he flippantly answered "object-oriented programming", and the name stuck. Smalltalk kept Simula's classes, but the big idea was messaging. As he put it in 2003: "OOP to me means only messaging, local retention and protection and hiding of state-process, and extreme late-binding of all things."

Bjarne Stroustrup used Simula for his PhD simulations at Cambridge, loved how it let him structure programs, and found the implementation far too slow. So in 1979 he bolted Simula's classes onto C, and "C with Classes" became C++. It kept the classes and the static types, and dropped the messaging and most of the late binding, so the compiler could make it fast.

Alan has been drawing the contrast ever since. In his own words, correcting someone here who misquoted him: "I invented the term 'object-oriented', and I didn't have C++ in mind."

Then David Ungar and Randy Smith took something away. Self removed the classes. Only objects remain, and they inherit directly from other objects through parent slots. An object can have several parents, so you get multiple inheritance for free, and since parents are just slots, you can change them at runtime. There's no assignment syntax either: variables are slots you send messages to. The title of the 1987 paper says what it was about: "Self: The Power of Simplicity."

https://selflanguage.org/

A language that dynamic was supposed to be too slow to use, so Craig Chambers, Urs Hölzle and Ungar invented the techniques that made it fast anyway: maps (hidden classes), customization, polymorphic inline caches, adaptive recompilation, and deoptimization (pessimization) so you could still debug optimized code.

That work went through Animorphic's Strongtalk to Sun and became Java's HotSpot, and Lars Bak carried it on into V8 for JavaScript. JavaScript's design credited Self, but missed the point by subtracting the one thing Self was about: simplicity. Brendan Eich never understood simplicity, or even the $1000 question: equality.

https://dorey.github.io/JavaScript-Equality-Table/

Anders Hejlsberg, who designed Turbo Pascal, Delphi, C#, and then TypeScript to clean up after JavaScript, at a 2019 panel with Guido van Rossum, James Gosling and Larry Wall:

https://news.ycombinator.com/item?id=19568378

>"My favorite is always the billion dollar mistake [Tony Hoare's name for null] of having null in the language. And since JavaScript has both null and undefined, it's the two billion dollar mistake." -Anders Hejlsberg

>"It is by far the most problematic part of language design. And it's a single value that -- ha ha ha ha -- that if only that wasn't there, imagine all the problems we wouldn't have, right? If type systems were designed that way. And some type systems are, and some type systems are getting there, but boy, trying to retrofit that on top of a type system that has null in the first place is quite an undertaking." -Anders Hejlsberg

Self's ideas (speculate on what you've observed, guard the assumption, bail out when it breaks) are how everybody's JIT works now, from .NET's tiered compilation for C# to LuaJIT's traces. Separately, Self's prototypes became JavaScript's object model, and Lua's metatables follow the same prototype approach.

The irony is that Self's compiler was the reward for simplicity, and it became the subsidy and license for complexity. The same techniques now make Java, JavaScript, C# and Lua run fast no matter how complicated their object models get, which flies in the face of the key word Ungar and Smith put in the title: simplicity.

Then Ungar, Harold Ossher and Doug Kimelman at IBM took the next thing away. Korz removed the objects and kept the slots. A program is a flat sea of slots that belong to nothing, each guarded on named dimensions, and a message is sent in a context of dimension bindings that flows implicitly down the call chain. The receiver becomes one ordinary dimension (rcvr) among any number. Group the slots by rcvr and you see ordinary objects again, but that's just one view, and no view is the privileged one. Once again the title leads with the point: "Korz: Simple, Symmetric, Subjective, Context-Oriented Programming" (Onward! 2014).

https://dl.acm.org/doi/10.1145/2661136.2661147

The name comes from Alfred Korzybski, whose Science and Sanity (1933) argued how much perspective shapes perception, and who gave us "the map is not the territory." It's a fitting name, because Self's implementation was built on maps: hidden structures describing the layout of objects that share a shape, which the programmer never sees, while the objects themselves are the territory. (V8 still calls its hidden classes Maps.) In Korz it's the other way around. The slots are the territory, and objects are just maps of it, one of many possible projections. Self hid its maps behind the objects, and Korz shows the objects were maps all along.

Look at that title and you can see what happened in between. When the receiver is the only thing allowed to vary behavior, everything else that needs to vary behavior has to start its own movement. Subject-oriented programming (Harrison and Ossher, 1993) varies by who is looking. Aspect-oriented programming (Kiczales et al. at PARC, 1997) varies by which concern cuts across. Context-oriented programming (Hirschfeld, Costanza and Nierstrasz, around 2005-2008) varies by what situation you're in. Then there's feature-oriented, role-oriented, and the rest.

Each one takes the same mechanism and freezes a different dimension into its name. Ossher co-invented subject-oriented programming, and with Korz he and his colleagues argued that all of these are projections of one smaller mechanism: dispatch on any number of named dimensions.

So I propose continuing the tradition by removing the next thing that complicates matters: the modifier. Object-Oriented Programming, minus the Object guard, is just Oriented Programming. Behavior is chosen by where you stand along whatever dimensions you've declared, and none of them is privileged in the name. How it's oriented matters less than whether it's oriented.

Oriented languages have one declared bearing that everything else follows, whatever that bearing is: Smalltalk and Self (objects receiving messages), CLOS (generic functions dispatching on all their arguments, with method combination), Korz (slots, guards and dimensions), Erlang (isolated processes sending messages, which is why Joe Armstrong concluded it might be the only object-oriented language), Lisp (lists), Forth (the stack), APL (arrays), Tcl (strings), Lua (tables), Prolog, Datalog and SQL (relations), and Unix (files and pipes).

The corollary is Disoriented Programming: a language that names one dimension in its paradigm, while its real behavior depends on a dozen unstated ones scattered across unrelated mechanisms. It comes in two flavors, naive and diabolical.

The classic naive case is PHP. It was never designed so much as accreted, one "next logical step" at a time, with open contempt for computer science and for design itself. Rasmus Lerdorf said as much: "I have absolutely no idea how to write a programming language, I just kept adding the next logical step on the way." and "We have things like protected properties. We have abstract methods. We have all this stuff that your computer science teacher told you you should be using. I don't care about this crap at all." The result has no bearing at all: functions, classes, traits, magic methods, superglobals, variable variables, and a standard library whose argument order you have to look up every time.

https://eev.ee/blog/2012/04/09/php-a-fractal-of-bad-design/

C++ is disoriented in many of the same ways, but on purpose. Every mechanism was deliberately chosen, carefully argued, and added on the principle that you don't pay for what you don't use. The upshot is that the behavior of a single call can depend on classes, templates, overloading, argument-dependent lookup, virtual versus non-virtual, implicit conversions, macros and friends, all interacting exactly as specified. That's diabolical, and Stroustrup knew it: "Within C++, there is a much smaller and cleaner language struggling to get out." It's still not what Alan had in mind.

Most other mainstream languages drift somewhere between those two poles. In enterprise Java, annotations, reflection, dependency injection and aspect weavers decide more than the classes do. JavaScript has prototypes underneath, class syntax on top, and several different rules for what "this" means. C# and Scala keep adding features instead of taking them away.

Disoriented doesn't mean useless. Those dimensions of variation are real and necessary, which is exactly why all those mechanisms got bolted on. It's disoriented to pretend there's only one direction on the compass, and hide all the others in places the language won't admit are part of the model.

I've written this up at more length as a Chip Morningstar-style "How to Deconstruct Almost Anything" deconstruction: declassification, then deobjectification, then what's left:

How to Deconstruct Almost Anything:

https://www.fudco.com/chip/deconstr.html

https://news.ycombinator.com/item?id=6389498

How to Disorient Almost Anything:

https://github.com/SimHacker/moollm/blob/main/designs/korz/d...

>Marvin Minsky saw the same enthronement in psychology. In a 1982 essay he demolished what he called the Single Agent theory -- the folk idea of "a little person deep down there" who does the real mental work -- and concluded: "Self, itself, is not a single thing." He wrote that five years before Self the language shipped, and it reads as a prophecy of what came next.

That leaves an open question for David Ungar: having demoted the receiver, would he go the rest of the way, drop the modifier, and call the whole genre Oriented Programming?

Me too. It's a shame he doesn't post here more often, because Quora's thoroughly enshitified user interface is so spectacularly hard to use and intentionally, aggressively, darkly patterned.

Quora has at least three different ways of folding content, and each one needs its own click: answers truncated at "(more)", comments collapsed behind "View comments", and nested replies collapsed again behind "View more replies", yet tellingly no "Expand all" button.

For logged-out readers there's also a login wall that blurs the rest of the page. The whole thing is fragile. Click the wrong thing, hit Back, or refresh, and it forgets everything you expanded and where you were scrolled, and dumps you back into a feed of unrelated "related" answers.

Worst of all, there's no way to link to a comment so that it restores your viewpoint and opens everything back up. The link lands on a page with everything folded again, and whoever you sent it to has to redo all the clicking to find what you meant. While HN has one kind of fold, [–], and every comment has a permanent item id that takes you straight to it, expanded and in context.

Maybe his last long visit here didn't leave him with a good impression of the "civilized behavior" of Hacker News. hota_mazi aggressively argued that Alan didn't coin the term "object-oriented," and then, when challenged, posted a bunch of unsubstantiated disrespectful misinformation.

Worse, hota_mazi did it while attacking Alan's friend Joe Armstrong in Joe's own memorial thread, days after Joe died, when Joe could no longer answer for himself. Alan exasperatedly asked him twice to do his homework.

Joe Armstrong died on April 20, 2019. The next day his essay "Why OO Sucks" was posted here, and the thread became a place to remember him.

https://www.cs.otago.ac.nz/staffpriv/ok/Joe-Hates-OO.htm

https://news.ycombinator.com/item?id=19715191

arendtio wrote:

> Actually, this is not really about if OO sucks, but to reflect on one of the articles Joe Armstrong wrote. Joe passed away two days ago.

oldpond wrote:

> Joe was truly one of the greats. [...] Thank, Joe.

(Not everyone was so kind. Someone posted just "Why Joe Armstrong sucks"; it's [dead].)

The top comment, by rhblake, quoted Joe's own 2010 explanation of why he changed his mind about OO:

> "Then, my thesis supervisor said "But you're wrong, Erlang is extremely object oriented". [...] Alan Kay himself wrote this famous thing and said "The notion of object oriented programming is completely misunderstood. It's not about objects and classes, it's all about messages"."

That's Joe, in his own words, crediting his supervisor and Alan. hota_mazi replied to it, two days after Joe's death, by accusing both men of opportunism [log in and set showdead=true to view flagged posts]:

https://news.ycombinator.com/item?id=19716281

hota_mazi on April 22, 2019 [flagged]:

> Both Alan Kay and Joe Armstrong struck me as having had the same attitude of trying to capitalize on the topic of object oriented programming, failing to recognize its importance, and then later trying to appropriate it by redefining it.

> Not the best moment of these otherwise two bright minds.

skndr asked:

> Didn't Alan Kay coin the term "object oriented"?

Before Alan had even joined the thread, hota_mazi dismissed Alan's own account of his own work:

https://news.ycombinator.com/item?id=19716318

hota_mazi on April 22, 2019:

> That's what he claims but there's zero evidence besides his own word.

lliamander asked the obvious question:

> Well, how large is the pool of other possible candidates? Wouldn't someone from that time period (say the Simula folks, or another PARC employee) challenge that assertion?

So did DonaldPShimoda:

> Ah, so you have evidence that it was somebody else?

hota_mazi admitted he had none:

> I don't, but that's not how the burden of proof works.

DonaldPShimoda, who works in programming language research, set him straight:

https://news.ycombinator.com/item?id=19716632

> Every source I've ever come across on this topic (and I work in PL research) points to Kay as the originator of the term "object-oriented" in relation to programming. No exceptions.

> You are now making an affirmative assertion that Alan Kay did not coin the term. The burden of proof is on you, not him.

hota_mazi demanded the sources while still rejecting the claim while hypocritically not doing any homework or providing any sources to his misinformation:

> Link these sources, then! Even someone who recently interviewed him and researched the subject for months confessed he could never corroborate that claim.

> You make the claim he coined the term, the burden of proof is on you.

> Until you do, it's perfectly reasonable and intellectually honest to reject that claim.

DonaldPShimoda:

https://news.ycombinator.com/item?id=19716791

> This would be just like saying "Well I don't think da Vinci really made the Mona Lisa. I mean, all we have is his word for it." [...]

> Your position is not "intellectually honest" because it sincerely looks like you're just trying to be antagonistic.

Then Alan arrived and said it plainly, in his own words:

https://news.ycombinator.com/item?id=19717640

alankay on April 22, 2019:

> I didn't coin the term "object" -- and I shouldn't have used it in 1966 when I did coin the term "object-oriented programming" flippantly in response to the question "what are you working on?".

And he replied directly to hota_mazi's first comment:

> This is way off. Please try to do more homework.

hota_mazi wasn't done with Joe. lliamander had challenged him:

> I'd be really interested to hear what you think they missed, because I find your claim to be surprising and a bit preposterous.

So, in the thread where people were mourning Joe, hota_mazi explained that Joe had been a bandwagon-chaser who bent the definition of OOP to cash in on its success:

https://news.ycombinator.com/item?id=19716419

hota_mazi on April 22, 2019 [flagged]:

> Armstrong wrote the very famous "Why OO sucks" and then a decade or two later, changed his mind when he saw how successful OO was, and then tried to retrofit Erlang into an OO language. Not by changing Erlang, but by twisting the definition of OOP so that Erlang would fit it.

That contradicts Joe's own explanation, quoted at the top of the same thread, and Joe was no longer alive to correct it. revvx did it for him:

https://news.ycombinator.com/item?id=19716488

> Joe Armstrong was criticizing C++-style OOP when he wrote his critique. After he learned more about Alan Kay's view on OOP, he decided that Erlang is closer to Alan Kay's OOP and he approves that specific flavor of OOP. He didn't change his stance based on popularity.

And Alan, two days after losing his friend, was left defending Joe's character:

https://news.ycombinator.com/item?id=19717646

> That isn't what happened at all (see the rebuttal by revvx). Joe was a great guy and also a great systems thinker. And he was the last person to worry about "bandwagons" (quite the opposite!)

hota_mazi doubled down, arguing that since mainstream OOP ended up meaning something else, Alan's and Joe's view didn't count:

https://news.ycombinator.com/item?id=19716595

> He doesn't even mention C++ in his essay [1], but regardless, the C++ OOP is pretty much the mainstream OOP, which we still use today in Java, Kotlin, C#, etc...

> And... no, the change in mindset about OOP never happened. Kay and Armstrong's view of OOP never took on. Today, OOP is still not seen as message passing and mostly seen as polymorphism, parametric typing, classes/traits/interfaces, and encapsulation. The complete opposite of what Erlang is.

> [1] http://harmful.cat-v.org/software/OO_programming/why_oo_suck...

revvx:

https://news.ycombinator.com/item?id=19716625

> I'm the one mentioning C++. To anyone familiar with both styles, Joe Armstrong is clearly not talking about Smalltalk-style OOP in his essay, he's talking about C++/Java/etc style. And later on he only praised Smalltalk-style OOP.

To which Alan could only say, again:

https://news.ycombinator.com/item?id=19717662

> Again, please do your homework.

On top of that, people doubted it was really Alan at all. hannofcart asked:

> Are you the Alan Kay. Is there any way we can verify this is you? The HN user account seems to have a very low "karma" rating, so one can't help but be more suspicious.

Alan answered:

> I'm the "computing Alan Kay" from the ARPA/Parc research community (there's a clarinettist, a judge, a wrestler, etc.) I did create a new account for these replies (I used my old ARPA login name).

DonaldPShimoda still wasn't sure:

https://news.ycombinator.com/item?id=19721376

> I'm a little skeptical. [...] A one-day-old HN account claiming to belong to one of the most important people in CS from the past 50 years seems a little suspicious haha.

That's what Alan was answering with his weary verdict:

https://news.ycombinator.com/item?id=19721772

alankay on April 22, 2019:

> An interesting and unfortunately true commentary on the lack of civilized behavior using technology that actually required a fair amount of effort -- and civilized behavior -- to invent in the first place.

(To DonaldPShimoda's credit, he apologized, and Alan graciously reminisced about crawling over Simula machine code listings unrolled down the hallways of the Merrill Engineering Building.)

A week later Alan was still correcting the record, when someone misquoted him:

> Actually, I said: "I invented the term "object-oriented", and I didn't have C++ in mind". In other comments here I explain why "object-oriented" was a too quick and bad choice for what I thought I was doing ...

Nice to see they let MIT-MC outside to run in the sun. Free range mainframes are the happiest mainframes.

https://icm.museum/blog/wp-content/uploads/2025/06/IMG_4422-...

https://icm.museum/blog/?p=38

It's all just a big scam to scare the public into buying robot insurance.

https://www.youtube.com/watch?v=g4Gh_IcK8UM

Waiter, there are fingernails in my hamburger menu!

"I'm not a language model, but ..."

https://en.wikipedia.org/wiki/I%27m_not_racist,_but...

Moltix would have been a better name than OpenClaw.

It's tempting to write a PDP-10 emulator for the Atari ST called TOAST.

FWIW I'm developing "tiny-titan", a stand-in for Cambridge's Titan mainframe that talks to Heinz Lemke's 1972 PIXIE program over an emulated version of Neil Wiseman's PDP-7 <=> Titan link. It doesn't emulate Titan itself, just the conversation PIXIE had with it, so the unmodified 1972 PDP-7 code dials home and uploads its drawings.

https://en.wikipedia.org/wiki/Titan_(1963_computer)

>Titan was the prototype of the Atlas 2 computer developed by Ferranti and the University of Cambridge Mathematical Laboratory in Cambridge, England. It was designed starting in 1963, and in operation from 1964 to 1973.

https://news.ycombinator.com/item?id=49407938

https://news.ycombinator.com/item?id=40617894

Flight of the PIXIE - Yuja Wang:

https://www.youtube.com/watch?v=jDrqR9XssJI

UNIVERSITY MATHEMATICAL LABORATORY, CAMBRIDGE: Cambridge Supervisor - Planning Document 10 Software for the Titan/PDP-7 link:

https://cucps.soc.srcf.net/titan/supplan/pd10.htm

Here is a photo of Heinz Lemke operating PIXIE with the light pen and 340 display on the PDP-7 (also seen in the video above):

https://www.facebook.com/groups/779220482206901/posts/629772...

It seems unlikely for a Sun worshiper to develop a philosophy of total brotherhood. Sun worship is usually a primitive superstition religion.

https://www.youtube.com/watch?v=WNfTwGu9FpU

Alan's lament about MVC applies to many things in computing:

https://news.ycombinator.com/item?id=8841428

>I asked Alan Kay about his thoughts on MVC:

[...]

>From: Alan Kay

>Things seem to hang on in computing just because they work a little bit.

>MVC was originally done at PARC almost 40 years ago. The good part was philosophical -- the idea to adapt the notion of "cameras" and "worlds" in the original 3D graphics stuff I participated in at Utah 45 years ago. The bad part of MVC was how we implemented it -- much too much machinery, etc.

>We (my various groups since then, including Viewpoints Research) have not thought about MVC since, but have used and devised various viewing methods over the last 20+ years. I like to do views as "watchers" which do not affect what they are viewing. There are lots of ways to do this. Similarly, I like to also use "watchers" (context sensitive to the views) to catch needed inputs. We have never done a really satisfactory automatic inverter for dealing with the loss of "dimensions" that happen when a view is made (but we have done some experimental ones).

>One important criterion is for end-users of all kinds to be able to easily make their own views in a very powerful ad hoc way via construction. We have done a number of adaptations and generalizations of how this can be done in Hypercard -- and this seems to work well (enough).

>Since we always roll our own languages and development systems, we don't care about problems that other systems might have. For example, we have very little knowledge about C#, etc. We do try to learn from the few good systems that are out there.

[...]

Speaking of vtables, at Kristen Nygaard's 100-year birthday celebration Bjarne Stroustrup also gave a fascinating talk after Alan Kay's, and they had some spicy back-and-forth discussion afterwards! Both call themselves Nygaard's heirs, anbd it was a delightful and respectful interplay between very different world views.

Kay came to Simula as a reader, turned it into Smalltalk, and later knew Nygaard and Dahl as colleagues. Stroustrup was taught by Nygaard in person, as a student at Aarhus, and then used Simula for his PhD.

Roughly: Stroustrup said he never took much from Smalltalk. What he took from Simula was the static part, compile-time guarantees and a direct map to hardware with zero-overhead abstraction, and C++ was never meant to be just an object-oriented language, since not everything is a class hierarchy or a virtual function. Kay argued that late binding pays for itself because the human is the slow part of an interactive system, and that static typing is a good idea applied prematurely. They agreed that the real job of an operating system or the internet is never to crash and never lose anything, and came at it from opposite ends: Stroustrup is working on guarantees against dangling pointers, out of range access, and uninitialized memory in C++, while Kay pointed out that Smalltalk protected every object dynamically.

Alan Kay's talk:

https://au.cloud.panopto.eu/Panopto/Pages/Viewer.aspx?id=fe0...

Bjarne Stroustrup's talk:

https://au.cloud.panopto.eu/Panopto/Pages/Viewer.aspx?id=fe0...

The discussion afterwards:

https://au.cloud.panopto.eu/Panopto/Pages/Viewer.aspx?id=fe0...

If you hate llm generated summaries then you can stop here and go watch the entire video yourself, but here are timestamps and summaries for people who don't have five hours to spare (although I highly recommend it -- I was watching it in real time when I witnessed the feedback performance between talks):

4:56:49: Stroustrup says he was never much inspired by Smalltalk. What he took from Simula was the static part: compile-time guarantees. "It would be nice to say yes, but to be honest, not much."

4:58:25: Stroustrup on garbage collection versus scope-based resource management (RAII): nobody has managed to combine them. Java's finalizers are his example, and somene mentions Lars Bak, "also from here" (Aarhus), says never use finalizers, they're evil.

5:00:24: Banter. Someone asks whether there's anything he likes about Smalltalk, and the reply is "Anything you like about me?"

5:00:47: Kay agrees reuse isn't a good reason for much, asks why people cling to old languages, and brings up the CrowdStrike crash taking down hospitals.

5:02:05: Stroustrup says CrowdStrike was a violated configuration rule, not a language problem. Programmers and managers are conservative and "confuse familiar with simplicity." He's not saying C++ is right for everything, and Python's all-dynamic approach is successful.

5:04 to 5:06: Kay says late-bound slowness pays for itself because humans are the slow part of interactive computing. Computing is held back by corporate legacy, and PARC was lucky to build all its own hardware and software.

5:07: An audience question about the next ten years. Kay says operating systems and the internet put you in a different seat of responsibility: the goal is never to crash and never to lose anything.

5:08:59: Stroustrup agrees, but says he doesn't control any operating system. He's working on guarantees in C++: no dangling pointers, no out-of-range access, no uninitialized memory.

5:09:55: Kay says typing is a really good idea, just premature in its static form. Smalltalk's dynamic typing protected every object.

5:10:34: Stroustrup says it's very hard to get hardcore developers to stop believing they can crash a system.

5:11:59 to 5:13:40: Kay says the Smalltalk image was a complete operating system, and that he made a living writing microcode. The field is guilty of not keeping up with the hardware. Stroustrup says he tried to talk hardware makers into adding support features, in his PhD, and failed.

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.

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:

  {rcvr <= stack} pop() { ... }
  {rcvr <= stack, assertions <= true} pop() { ... check, then pop ... }

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.

If that sounds familiar, it's the same thing as Lisp Machine Flavors' before and after daemons, or CLOS's :before, :after and :around methods, or plain old subclassing: override a method, do some extra stuff first, call super (or call-next-method), then do some more stuff after. The more specific method gets the first crack at it, and decides whether and when the less specific methods run.

Korz just models that as slots with guards. The checking pop does its checks, then re-sends pop with assertions: false, which no longer matches its own guard, so the plain pop runs. Method combination isn't a language feature you need a MOP to change, it's a pattern you write with ordinary dispatch. (What "super" should mean in Korz is still an open question, since there's no class or owner object to be "super" relative to.)

Guards are simple: for each dimension, a slot can ignore it, require it to be bound (binding its value as a parameter), or require its coordinate to be or inherit from a given coordinate, like assertions <= true or rcvr <= stack. Coordinates are objects with parents, so "<=" means "is or inherits from", not numeric less-than, and matching a constant is just the case of a coordinate with no children. No arbitrary predicates, so no Pascal-style ranges like 10 < x < 20, unless you make a coordinate for the range and have its members inherit from it.

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

Korz is multi-dimensional. Procedural programming is zero-dimensional, and object-oriented programming is one-dimensional (the implicit receiver parameter, usually spelled self, this, or rcvr), so both are the special cases 0 and 1 of Korz. Korz can dispatch on any number of parameters, none of them special like self or this, and the guards on the slots decide which slot is the most specific one to dispatch to.

So a Self program is just a Korz program that happens to use only one dimension, called rcvr. Objects are subjective and assemble dynamically depending on how you're looking at them (the coordinates of the dimensions), and in the special case of single dispatch on rcvr, everything looks like an object.

Call it the faith of our fathers. Kristen Nygaard and Ole-Johan Dahl gave us classes in Simula. Alan Kay gave us objects sending messages in Smalltalk. Claude Shannon had already given us a sender, a channel and a receiver, and object-oriented programming made the receiver the one privileged thing every message is about. David Ungar and Randall Smith took away the classes in Self. Then Ungar, Ossher and Kimelman took away the receiver in Korz.

Which makes it a lot like Philip K. Dick's "Faith of Our Fathers" (Dangerous Visions, 1967). The Party keeps everyone docile with hallucinogens, so everyone sees the same benign human Leader on TV. Tung Chien gets an anti-hallucinogen from a street vendor and sees what the Leader actually is, and it isn't a man. The reversal is that the shared view was the drugged one, and when he meets the underground, it turns out that each of them saw something different.

There's no single true form, just what each viewer brings. Single dispatch is the stuff in the water: it makes everybody see the same objects. Korz is the antidote, and what an object looks like depends on the coordinates you're looking from. In Dick's afterword he quotes John Scotus Erigena, from AD 840: "We do not know what God is. God Himself does not know what He is because He is not anything." A Korz object isn't anything either, until a context gathers its slots.

https://en.wikipedia.org/wiki/Faith_of_Our_Fathers_(short_st...

That's also why you don't need things like the Visitor pattern, which is a kludge for the fact that you can only dispatch on one parameter. Multiple dispatch is something some object systems support, like Common Lisp's CLOS and its MOP, but Korz takes it all the way and has no 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-...

Why would you want multiple dispatch? The Margolus neighborhood for block cellular automata is a great example. Rules apply to all four rotations of a block of four cells, so the neighborhood is Center, Clockwise, CounterClockwise, and Opposite, instead of just one self. You can write elegant, concise rules that way, and the compiler can produce efficient code or lookup tables.

https://en.wikipedia.org/wiki/Block_cellular_automaton

I've had success applying the ideas from Self to a file system based object system for LLM orchestrated simulations (moollm). Then David Ungar told me about Korz, which totally blew my mind and made me rethink a lot of things -- but it's beautifully backwards compatible with what I've been doing with Self.

Here are some notes on applying Korz to cellular automata (with neighborhood and time dimensions), and to adventure game parsers and simulators like Zork (with direct object, verb, indirect object, location, and player dimensions). David Ungar assured me Zork is only coincidentally an anagram of Korz, but it's too sweet a coincidence to pass up, because Korz is really useful for elegantly modeling that kind of stuff.

https://github.com/SimHacker/moollm/tree/main/designs/korz

Recently I've been thinking about how to apply Korz to LLM driven simulations, which I'm calling Korz' (Korz-Prime):

https://github.com/SimHacker/moollm/tree/main/designs/korz/k...

My favorite part was how Alan's exuberant "I realize what the fuck is going on and it's just so amazing" got distorted by YouTube's speech to text transcription replacing "fuck" with "[__]", adding another layer of censorship noise and interpretation to the mix.

And how the conference's real time speech to text transcription honored Alan's "fuck", but would occasionally lapse into Danish, and say things like "We will eat your hands".

dang> Hopefully Don won't mind!

Of course not, and I hope Alan won't either, since in the recording he laughed and said "Yeah, this will be this will be fun."

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:

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

It's only fair, since they allow planes on aircraft carriers.

The indie game Tiny Life is an homage cover of The Sims, played in the key of The Sims 0 -- like Little Computer People, 1985, one person and his dog living on one floppy disk. It has in soul what it lacks in resolution, and soul was always the hard part.

https://tinylifegame.com/

Playing Tiny Life for the first time!

https://www.youtube.com/watch?v=nRLkrxRJiRI

One important premise of Scott McCloud's book Understanding Comics is that you can trade resolution for identification and empathy. Lower graphical resolution is not just pixels swapped for soul as if it were a compromise, it's the mechanism that produces the binding. Every specific a face carries is a specific that can contradict the player, so subtracting detail buys the player room inside the character. A photorealistic face is somebody else's; a six-pixel face is yours.

https://en.wikipedia.org/wiki/Understanding_Comics

Scott's point is that when the world is concrete but the person is iconic, the player wears the person while believing the place -- which is what The Sims did with mumbling low-poly people in carefully detailed rooms, and what LCP did with one man drawn in a handful of pixels whom players named and worried about for forty years.

He calls the effect "masking":

https://en.wikipedia.org/wiki/Masking_(comics)

Little Computer People Review (Commodore 64):

https://www.youtube.com/watch?v=xBRXWUVMAg4

The Sims wouldn't exist without This | Nostalgia Nerd:

https://www.youtube.com/watch?v=rYz_leh9J3E

That is why "soul over resolution" is not a hedge about the graphics, it's a claim about what the graphics are for.

Will Wright, Maxis, "Interfacing to Microworlds", Terry Winograd's user interface class at Stanford, April 26, 1996, previewing the Dollhouse prototype that became The Sims:

https://www.youtube.com/watch?v=nsxoZXaYJSk&t=4470s

Student: What about from person to person, you talking about the information that's contained within the objects, so there can be information in another person, that you want to interact with in the environment. Have you looked at any reasons why you would want to do that?

Will Wright: Oh yeah, I mean, that's that's the hard problem. I mean, simulating ants is hard enough, when you get to people there's really no hope.

There are two issues here. You can look at this as a technology. It's not a product right now. And there are a few directions this could go. I could see this becoming, let's say, a multiplayer network MUD kind of a thing. You might have a thousand people playing SimCity from the bottom up, each person building their own house in a big multi-user space. In which case that issue is a little less important, because most of the people are real people, and you're dealing with puppets.

As a standalone game, which is probably our closer target, we have to deal with the problem you're bringing up, which is how do we deal with people to people? And it's hard, I mean there's just -- I'm sure Terry can elaborate on that more than I can. But the best thing we can do is prop up a convincing illusion. We don't have to be doing a valid simulation of human personality. What we have to do is we have to put up something that's ambiguous enough to where somebody can read in what they want.

Actually in this thing what I have right now are people come up and they converse, but you don't hear what they're saying, they just gesture, and sometimes they look mad, sometimes they kind of look contemplative. It's kind of interesting how much people will read into that.

This is kind of dynamic that we've seen again and again where something happens in SimCity and they said "oh I was running my nuclear reactor near the red line, and then there was so much smoke coming out of it, this plane crashed, and because of that, this and that happened", and they'll describe this long causal chain of events that I know does not exist. I designed the simulation, I know that there's no linkage between the power output of the power plant, the planes crashing, but they're convinced it exists.

Don Hopkins: They're using it as a medium to tell stories about.

Will Wright: Yeah!

Don Hopkins: Where they're using it as a piece of paper, to write.

Will Wright: Yeah, that's exactly right. There's a parallel simulation going on here in the game. Everybody's taking a linear path through this, and they're basically, most people will attempt to understand things like this with a story. They'll think about "I did this, then that happened, because of that", and so the story becomes kind of their logical connection, their logical reverse engineering, of the simulation that they're playing inside of.

Now on the people's side, I think we can do a lot in this as a product, by propping up that illusion of people. Again, if this is a doll house, we don't want the dolls to be sentient things. We want the dolls to be interesting enough to where I can play games with them.

There was actually a really interesting doll that this company came out with. Oh, it was Worlds of Wonder, this really cool doll, I've got a couple of them after they went out of business. It's called the Julie doll. But it was like this $250 doll with voice recognition, and it said all these things. It had just a huge amount of ROM with digitized speech in it, and so it would sit there and try and have stupid conversations with you. And really it was kind of Eliza, or had keywords it would recognize, and give you these kind of non-committal responses.

But in the testing of that, well first of all it was a $300 doll. Who's going to buy the kid a $300 doll? So it was really more, it was actually the only doll I've ever seen that appealed to grown men. Grown men love this, I mean this is a hacker's doll.

But I talked to the guy who was working this project, and he said they put this in focus groups with girls. And they played with it for a while, and then after about a half an hour they take the batteries out, and keep playing with it.

And what was happening is that the girls were propping up this elaborate fantasy in their play, and the dolls were supposed to be a structure for that fantasy, they weren't supposed to be the fantasy. The doll was telling them what the fantasy was, and it was conflicting with what the girls were saying, and so it was interfering actively with their fantasy and their play.

So in that regard, I think we can actually kind of take that path with these people. And all we have to do is deal with them at a very local kind of a state machine, Braitenberg Machine kind of level, and say that they're angry, and they're hungry, and they're sleepy. And then we can actually do some things where maybe they have a little, what you might call, structural ambiguity about what they're actually saying.

One of the thoughts I had about this project in particular is that you'd see the people go up and they talk, and there would be some kind of a flavor to their conversation, but it would be more like Peanuts. When they did the TV show of Peanuts, you'd hear the adults talking, and the adults would always be like "mwa mwa mwa mwa mwa mwa", or soft, or loud. You can tell if they're mad, or angry, or what, but you wouldn't hear what they were saying. You'd have to read that into it.

I think this is the area where we sidestep the issue, just because as a commercial company we have to ship a game, we're not doing a research project. So that's a long winded answer, sorry. Yeah?

SORRY!!!!

https://youtu.be/oNG1DkS_f4g?t=132

I wish I could make Dijkstra Dingbats.

Why are you?

Then people could create their own custom models with silly names like Linux distributions or cannabis strains, and then it would be all about fashion and branding.

I know: Web rings for agents!

I always feel bad and guilty when coding with emacs, giving me such an unfair advantage over people using vi. This is the old way and things can be done that seemed impossible but I always have a bad feeling for vi users.

That's a different alignment problem than the one that's going to wipe out all life on earth.

AI is putting parrots and parrot trainers out of jobs.

This made my day! I love it when people on Hacker News mention Stochastic Parrots, and they're actually referring to the paper and its authors, instead of just mindlessly performing a reflexive drive-by anti-ai shibboleth by parroting a phrase they heard on the internet without any understanding of what it means, or what paper it refers to, or who wrote it, or what the conclusion and responses to the paper were. Thank you!

But we have to have a talk about stochastic pelicans riding bicycles...

The bike landfills from the bikeshare bubble are terrible, but I am not looking forward to the pelican landfills from the AI bubble.