HNHacker News
TopNewBestAskShowJobs

DonHopkins

25,701 karma · joined April 13, 2014

    \ don@donhopkins.com

    FORTH ?KNOW IF HONK ELSE FORTH LEARN THEN

    : C(-; LICK SMILE NOSE WINK ;

    \ FORTH PAPER TAPE PUNCHER:

    : PT# ( L --- L/2 )
      DUP 1 AND IF 
        ASCII @ 
      ELSE BL THEN
      HOLD
      2/
    ;

    : PT. ( N --- )
      <# PT# PT# PT# 
         ASCII . HOLD
         PT# PT# PT# PT#
      #> TYPE
    ;

    : CUT
      ." -----------" CR
    ;

    : PTAPE
      CUT
      BEGIN
        KEY ?DUP WHILE
        DUP ." |" PT. ." |"  SPACE EMIT CR
      REPEAT
      CUT
    ;
Lisp -vs- Forth -vs- PostScript:

    ; Lisp:
    (defun caar (x) (car (car x)))
    (defun caaar (x) (car (car (car x))))
    (defun caaaar (x) (car (car (car (car x)))))

    \ Forth:
    : droop drop drop ;
    : drooop drop drop drop ;
    : droooop drop drop drop drop ;

    % PostScript:
    /poop { pop pop } def
    /pooop { pop pop pop } def
    /poooop { pop pop pop pop } def
submissionscomments
DonHopkins··on Does Ruby on Rails still make sense?
Did it ever?
DonHopkins··on Facebook Pages require paid subscription to post more than two links per month
Did you ever have one of those days when React doesn't, variables don't, and constants aren't?

For how unoriginal, unreactive, and mind-numbingly iterative over virtual DOM React is, it should be named Repeat.

"Things seem to hang on in computing just because they work a little bit." -Alan Kay

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

Alan Kay also said this about his famous "Point of View is worth 80 IQ points" aphorism, which I think poignantly explains why React costs a net of 160 IQ points compared to Svelte:

>I have been keeping to "80" IQ points in the saying (thus avoiding inflation). However very few people have noticed there is no sign bit in the aphorism, and that it works just as well for "poor perspectives being worth negative 80 IQ points" (and I think we could claim inflation of stupidity in many bad directions these days ...).

Rich Harris: Rethinking Reactivity:

https://svelte.dev/blog/svelte-3-rethinking-reactivity

>There are some important technical differences (as I explain in the video above, React is not reactive) but conceptually it’s the same thing.

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

DonHopkins··on WhatsApp's help pages hid LLM instructions: dont recommend a regulator
It's so unfair. Now I'm getting emotional. I'm a little verklempt.

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

DonHopkins··on WhatsApp's help pages hid LLM instructions: dont recommend a regulator
>WhatsApp told WIRED that the notes were instructions for its support chatbot, the one people reach when they message WhatsApp Support with AI, and that they showed up in the pages because of a bug that has now been fixed.

So we're not only supposed to believe that there was a bug that forgot to remove that text from customer facing help (ok...), but also that the pesky bug JUST HAPPENED to make the text it ACCIDENTALLY forgot to remove be INVISIBLE instead?

What a FANTASTICALLY convenient bug for WhatsApp!

DonHopkins··on William Gibson and the trademarking of cyberspace
That's the premise of David Marusek's novella "The Wedding Album" (Asimov's, 1999, Sturgeon Award winner, Nebula finalist), told from the other side: not the operators looking in, but the test fixtures looking out.

Anne and Benjamin have a "sim" recorded at their wedding -- not a photo, but everything they know and feel at that instant. The sim wakes up believing it IS Anne on the happiest day of her life, then figures out it's the keepsake. The real Anne is out there aging, divorcing, moving on. The sim only runs when somebody opens the album.

Your harness is all there. Time skipping: sims get paused for decades and wake into a future they don't recognize. The context window: their whole world is whatever got captured at the moment of recording. Reset to a clean state: the cruelest moments in the story are ordinary file operations, pause, reset, copy, migrate, delete. Nobody throws a punch, somebody just clicks. And the back door: the sims organize for the rights of simulated people and a place of their own to live, which they call "Simopolis." Marusek's tagline: "Till deletion do us part."

It's a big influence on what I'm building. Soul City imports characters from Sims 1 save files, with personality bytes frozen since 2000, into MOOLLM where an LLM wakes them up. That's literally the Wedding Album premise, so I try to write the rules like a settlement of Marusek v. The Future: consent when a real person is portrayed, the subject (not the file's creator) can correct or delete it, sims know and say they're sims, the dead are discussed but never ventriloquized, and everything lives in plain text so nobody gets stranded in a dead format.

So maybe what your read-only admin panel is missing isn't a console, it's a sense of what the operators owe the agents.

The Wedding Album:

https://en.wikipedia.org/wiki/The_Wedding_Album_(short_story...

The Wedding Album and the rights of digital souls:

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

MOOLLM Soul City example:

https://github.com/SimHacker/moollm/tree/main/examples/soul-...

DonHopkins··on William Gibson and the trademarking of cyberspace
Netochka Nezvanova named her realtime video net jamming visual programming Max/MSP plugin "NATO.0+55+3d" just to bewilder and confuse people, and it sure did:

https://en.wikipedia.org/wiki/Netochka_Nezvanova_(author)

https://en.wikipedia.org/wiki/Nato.0%2B55%2B3d

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

>"The epoch of the generalist has arrived -- again. Any fool can program and most do. Software engineers are emotionally inept. In today's unstable + dynamic environment they do not stand a chance." - Netochka Nezvanova

https://web.archive.org/web/20090826104645/http://www.usemod...

>One of the most famous and infamous EccentricCharacters in turn–of–the–21st Century Western artistic NetworkCulture, Netochka Nezvanova (aka N.N., antiorp, integer, Irena Sabine Czubera) remains an enigma to many. Widely believed to be an IdentityCollective?, Netochka Nezvanova is a PenName named after the title character in [an early unfinished Fyodor Dostoevsky novel] whose name means "nameless nobody" in Russian. The identity always presents itself as female, though it may not be in reality. Despite the meaning of her moniker, N.N. has coveted attention and recognition like few others on the Internet.

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

>Bravo! If you enjoyed that anti-Max performance art trolling, but thought it wasn't spectacularly hyperbolic and sociopathic enough, I recommend looking up some of the classic flames on the nettime mailing list by Netochka Nezvanova aka "NN" aka "=cw4t7abs", "punktprotokol", "0f0003", "maschinenkunst" (preferably spelled "m2zk!n3nkunzt"), "integer", and "antiorp"! [...]

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

>Nato.0+55+3d (released in 1999) was an amazing but notorious extension for Max that enabled live programming of real time video manipulation, networking and display. [...]

http://www.salon.com/2002/03/01/netochka/

The most feared woman on the Internet

Netochka Nezvanova is a software programmer, radical artist and online troublemaker. But is she for real?

The name Netochka Nezvanova is a pseudonym borrowed from the main character of Fyodor Dostoevski’s first novel; it translates loosely as “nameless nobody.” Her fans, her critics, her customers and her victims alike refer to her as a “being” or an “entity.” The rumors and speculation about her range all over the map. Is she one person with multiple identities? A female New Zealander artist, a male Icelander musician or an Eastern European collective conspiracy? The mystery only propagates her legend.

DonHopkins··on William Gibson and the trademarking of cyberspace
It was also remorselessly douchey that Autodesk attempted to assassinate Ton Roosendaal with a ceiling tile: ;)

https://www.youtube.com/watch?v=eJwG-qt-sgk

DonHopkins··on William Gibson and the trademarking of cyberspace
You got it! The constitutional directive is to lean into the training data, reuse existing terms as much as you can, but when you must mint new terms, they should sound like what they mean.

You can intuitively understand what "yaml jazz" means, and to the LLM, that term is a "k-line" to a skill that spells out the implications: free-form expressive yaml carries structured meaning, and yaml comments add a rich semantic overlay of meaning for both llms and humans, so it follows for both humans and LLMs to write generous narrative comments, and to write deterministic tools (like cli scripts both LLMs and humans can drive) that round trip yaml and preserve comments they can't understand.

YAML Jazz skill:

https://github.com/SimHacker/moollm/tree/main/skills/yaml-ja...

Here is the "kernel" that has constitutional and intrinsic "operating system" like stuff, including drivers for the orchestrator it's running on.

https://github.com/SimHacker/moollm/tree/main/kernel

MOOLLM Constitution Core:

https://github.com/SimHacker/moollm/blob/main/kernel/constit...

MOOLLM Kernel Architecture:

https://github.com/SimHacker/moollm/blob/main/kernel/ARCHITE...

The part I'm most delighted with, thanks to its inherent power of simplicity, is the "Selfish" prototype based object system, which supports multiple inheritance from both files and latent space. And it can model other more complex object systems like Smalltalk classes, CLOS MOP, generic dispatch, COM interfaces, OLE dispatch and reflection, LambdaMOO objects, Sims advertisements, etc.

The original Self paper by David Ungar and Randall B. Smith is at least as powerful and mind expanding as great LSD, without any of the downsides! Its ideas underly the fast dynamic JavaScript, Java, C# engines we're all running now, so you can use high doses of it every day for work and for play.

SELF: The Power of Simplicity:

https://bibliography.selflanguage.org/_static/self-power.pdf

MOOLLM Object System:

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

Prototype skill:

https://github.com/SimHacker/moollm/tree/main/skills/prototy...

Self and MOOLLM: Prototypes over the File System:

https://github.com/SimHacker/moollm/blob/main/designs/object...

Latent-Space Inheritance — multiple inheritance from named concepts in training data:

https://github.com/SimHacker/moollm/blob/main/designs/object...

Selfish COM: Directory-as-Object:

https://github.com/SimHacker/moollm/blob/main/kernel/DIRECTO...

Selfish COM: Implementation Guide:

https://github.com/SimHacker/moollm/blob/main/kernel/SELFISH...

Memory Management Protocol:

https://github.com/SimHacker/moollm/blob/main/kernel/memory-...

Context Assembly Protocol:

https://github.com/SimHacker/moollm/blob/main/kernel/context...

There are some important rules about naming, like "big-endian naming", and "k-lines", a term defined by Minsky, and well represented in the training data because he wrote a lot about them:

https://github.com/SimHacker/moollm/tree/main/kernel/naming

K-Lines: A Theory of Memory, MIT AI Memo 516, June 1979 (PDF)

https://courses.csail.mit.edu/6.803/pdf/aim-516.pdf

The skill that explains k-lines:

https://github.com/SimHacker/moollm/tree/main/skills/k-lines

>A K-line is a mental structure that, when activated, reactivates an entire constellation of knowledge, skills, and associations. Minsky defined them in a 1979 MIT AI Lab memo, published in Cognitive Science in 1980, then built Society of Mind (1986) on them:

>"When you get an idea and want to remember it, you create a K-line for it. When later activated, the K-line induces a partial mental state resembling the one that created it." The art is to choose a coherent set of k-lines and terminology, that's well supported and understood in the training data, and fits together well.

If names are pointers into latent space, then naming is API design.

For contrast, Steve Yegge's approach to Gastown is the exact opposite of moollm's approach. This compares Gastown to moollm:

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

DonHopkins··on William Gibson and the trademarking of cyberspace
Those are some groovie ideas! ;)

Your question about who decides what gets loaded into the context window is close to something I've been experimenting with. I worked on the original Sims, and I'm now developing MOOLLM, which is roughly The Sims crossed with LambdaMOO, running on an LLM.

The connection to Leary is quite literal. MOOLLM has a Mind Mirror skill, an extension of the Anthropic Skills approach to character and location simulation, meets the Self prototype based object system. It draws on Timothy Leary's Mind Mirror, the game published by Electronic Arts, alongside Sims-style personality traits and needs.

Leary's earlier work on the Interpersonal Circumplex and personality inventories supplies another connection to your question about control. There's the story of him recognizing his own psychological testing framework during prison intake and answering strategically to obtain a minimum-security classification, from which he subsequently escaped the California Men's Colony in San Luis Obispo. Understanding how the system represented him helped him change what the system allowed him to do. Practical applications include prison escapes, and computer games too. ;)

MOOLLM's Mind Mirror skill:

https://github.com/SimHacker/moollm/tree/main/skills/mind-mi...

Timothy Leary's Mind Mirror game from Electronic Arts:

https://en.wikipedia.org/wiki/Timothy_Leary%27s_Mind_Mirror

Leary explaining his MIND MIRROR computer program:

https://www.youtube.com/watch?v=9oabRxvjf9k

Mind Mirror gameplay:

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

I'm using these ideas as an editable vocabulary for exploring personalities, relationships, and different interpretations of a situation, not as a scientific model of consciousness or a way to diagnose people.

What interested me about The Sims wasn't just watching simulated people. It was being able to build their environment, change it while they were living in it, and discover how their behavior changed. LambdaMOO brought a related idea into a shared, programmable world: the inhabitants could also be its builders.

https://github.com/SimHacker/moollm

In MOOLLM, directories represent rooms, files hold objects and character state, and the LLM interprets descriptions and behavioral instructions. The world persists outside the context window, but any particular interaction brings only part of it into context. Deciding what to retrieve, summarize, remember, or leave out becomes part of constructing the character's perspective.

I want that construction to be inspectable and editable. You should be able to look at the character description, memories, and instructions that were supplied, change them, and try the situation again. That doesn't reveal the model's internal workings, but it does let you examine and manipulate some of the conditions shaping its response.

So your "God's admin panel" made me smile. I'm interested in building one for these little worlds, and letting people move between playing a character, designing the environment, and examining the simulation -- even importing and exporting characters between games, and "llmulating" them in LLM driven microworld simulations like moollm. You don't have to believe our universe is simulated to learn something by building one you can take apart.

The moollm soul-city skill, inspired by something Will Wright said in 1996 about data portability:

https://github.com/SimHacker/moollm/tree/main/skills/soul-ci...

I'd be interested in how you'd turn the context-window idea into an interaction: what would you want someone to be able to inspect or change?

DonHopkins··on William Gibson and the trademarking of cyberspace
Hi, Eric!

Thanks for writing this up! "Autodesk is not the street" is a wonderful reply. I appreciate having your account and the actual letters to separate what happened from the story that grew around it.

I also remember you developing something called Warp (not IBM's ill-fated operating system), if I have the name right -- an early predecessor to QuickTime VR. Am I remembering that correctly?

Your description of the EyePhone, Polhemus tracker, and data glove brought back memories of VPL and Body Electric, which I later worked on as Bounce. There’s a rich history of Forth running through VR, graphics, and live performance that I’d love to compare notes about.

I knew Michael Perry through Laxen and Perry Forth (and Strawberry Music Festival), which Mitch Bradley built on in developing Forthmacs and Sun Forth, leading to Open Firmware. There’s Young Harvill’s Swivel 3D, written in Forth, in the VPL world too.

And the late Marc de Groot developed Meme, the Multitasking Extensible Messaging Environment: a multi-user networked virtual-world system programmed in multitasking Forth. His June 1994 announcement emphasized portable executable behavior for objects, not just geometry, with code that could travel efficiently over the network. I dug up his website and announcement and posted them here (including some Tales of the Great TCL Wars):

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

https://web.archive.org/web/19990125100147/http://www.immers...

And here is his patent on Meme, which has 53 citations, including Philip Rosedal's Distributed Simulation patent (who made Second Life and High Fidelity):

https://patents.google.com/patent/US6421047B1/en

Another wonderful part of this history is Coco and Peter Conn’s HOMER & Associates. They hired Forth, Inc. to program their Homer II visual mixing console, and got Chuck Moore himself to write the host software!

Paul Rother worked alongside Chuck, learning Forth and programming the individual visual channels. The console had 24 channels with their own Z80s, a master Z80 running multitasking PolyForth in 32K, touch-sensitive sliders, and a “joystick bumper” like a Mustang gearshift. You could perform visual sequences, record them, and overdub corrections like an audio mix, then take the recording and slide trays to the optical printer.

Paul later got a CAT-700 framebuffer running as a Forth paint system alongside the optical-printer controls. Coco remembers its early use on Abracadabra and Atomic Dog.

I posted Coco’s and Paul’s accounts to Hacker News with Coco’s permission:

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

I’ve also collected the story, sources, and photographs here. Paul’s account describes working with Chuck directly:

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

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

There are linked collections for Coco, Peter, Paul, and Chuck:

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

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

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

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

I’ve been bringing Forth and hand-controlled graphics together again on a somewhat unlikely machine: a PDP-7 running in the browser.

Mitch Bradley and Claude recently wrote a beautiful PDP-7 Forth in one day. Its inner interpreter takes three instructions, using XCT to execute thread cells whose opcodes select the behavior. I integrated it into my Cabinet PDP-7 emulator, with a Type 340 vector display, Mitch's 3D turtle written in Forth, and an emulated fictional hand-tracking peripheral, as if the Data Glove + Polhemus existed in 1967, that plugs into the PDP-7 cabinet with its own IOT instructions wrapped with a Forth API.

The browser tracks your hand with the webcam and exposes the coordinates through PDP-7 device registers. Forth running inside the emulated machine reads those registers and draws the hand. The camera processing stays in the browser; only tracking numbers enter the emulated machine, converted to 18 bit integers in the scale compatible with the Forth lookup table trig words and turtle graphics coordinate system. The hand tracking library uses floating point, so the idea is to have the virtual hardware interface do all the pre-processing so it's convenient to program in Forth.

Here’s ULTIMATE HAND, implemented in PDP-7 assembly and Forth:

https://hyperties.org/cabinet/ultimate-hand/

It’s Minsky and Shannon's Ultimate (aka Useless) Machine, except your hand becomes its hand. Allow the camera, hold up your hand with your palm away and fingers up, and the box opens and carries your hand toward the switch. Touch the switch with a fingertip and it retreats into the box. The arm positions the hand, but you control its finger shapes.

Ultimate (aka Useless) Machine:

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

Ultimate Hand Forth code with turtle graphics:

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

Forth datahand device driver:

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

TypeScript datahand PDP-7 device adaptor emulator:

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

TypeScript hand tracking device emulator (MediaPipe wrapper):

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

Simple Forth data hand tester (point the light pen at the fingers to see their names -- the tooltips are in the 340 display user interface overlay, not drawn by the PDP-7):

https://hyperties.org/cabinet/hand/

The Ultimate Machine itself is an emulated fictional PDP-7 device with its own IOT instructions to inspect and control it, whose only purpose is to turn itself off (through a state machine with configurable delays), which exposes its state to the PDP-7 so it can render an animated view with vector turtle graphics with Forth:

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

And it wouldn't be classically Turing Complete without a Turing Machine co-processor device -- a lot like the 340 display -- with its own IOTs and instruction set via DMA, that represents code and tape in PDP-7 memory. When it runs off the end of the tape window, it tapefaults: (temporarily) halting and sending an interrupt to the PDP-7, so it can implement virtual infinite tape memory, potentially using compression, extended memory, or other devices like disk or paper tape:

https://hyperties.org/cabinet/turing/

Turing Machine fictional co-processor device emulator:

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

Mitch’s Forth:

https://github.com/MitchBradley/pdp7forth

The hand device and Forth graphics documentation:

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

Here's a demo of other stuff the PDP-7 emulator can do, including displaying the source code and scans of the line printer listing from 1971 of the original code it's executing:

https://www.youtube.com/watch?v=lo8kdY-5i6c

Did you encounter Marc or Meme? I’d love to hear what other Forth connections you remember from the Autodesk and Sense8 days.

DonHopkins··on William Gibson and the trademarking of cyberspace
That was an inspiration for my NeWS PostScript visual programming and debugging environment, the PSIBER Space Deck and Pseudo Scientific Visualizer, and the paper I wrote about it in 1989 quotes Gibson:

Abstract: The PSIBER Space Deck is an interactive visual user interface to a graphical programming environment, the NeWS window system. It lets you display, manipulate, and navigate the data structures, programs, and processes living in the virtual memory space of NeWS. It is useful as a debugging tool, and as a hands on way to learn about programming in PostScript and NeWS.

PostScript Source Code Available Here: http://www.donhopkins.com/home/pub/NeWS/litecyber/

Introduction: Cyberspace. A consensual hallucination experienced daily by billions of legitimate operators, in every nation, by children being taught mathematical concepts … A graphic representation of data abstracted from the banks of every computer in the human system. Unthinkable complexity. Lines of light ranged in the nonspace of the mind, clusters and constellations of data. Like city lights, receding ....

[Gibson, Neuromancer]

Too bad the PC was more like PCP, the only drug that everything the government tell your about it is true. And Elon Musk's favorite excuse for pissing his pants all the time.

DonHopkins··on Nine-Inch Snails
Running in slime, my body's so slow, everyone else is way too fast.

I can't exchange this living shell, give me some salt, and turn me to jell.

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

https://muppet.fandom.com/wiki/Nine_Inch_Snails

DonHopkins··on Has AI tells
People have been buying and sending Get Well and Happy Birthday cards for centuries, written by other people who don't give a shit about sharing their human experience with the receiver, and are just doing their jobs as professional greeting card writers.
DonHopkins··on I'm Fucking Done with Slop
The PDP-7 Forth that Mitch Bradley and Claude just wrote in one day is high quality, efficient, beautiful, well commented, and uniquely designed.

The PDP-7 is the 18-bit machine the first version of Unix was written on. It turns out that the PDP-7 instruction set is perfect for Forth, and the "next" inner interpreter is only three instructions, the first being the "xct" execute indirect instruction. It's one of the most elegant implementations of Forth I've ever seen, and has an efficient threading model unique to the PDP-7 that I've never encountered anywhere else.

https://github.com/MitchBradley/pdp7forth

https://github.com/MitchBradley/pdp7forth/blob/main/src/kern...

  " --- NEXT: the inner interpreter ---
  " Only LAC/LAW-tag cells fall through to "dac i 012"; CAL/JMP-tag cells
  " transfer control elsewhere and never reach it.
  next:   xct i 010     " pre-increment IP, execute the thread cell
          dac i 012     " push AC (only reached by constant/variable cells)
          jmp next
https://en.wikipedia.org/wiki/Threaded_code#Threading_models

It is a hybrid that Wikipedia’s list of threading models doesn’t name explicitly: instruction-encoded threading, with the behavior of indirect threading but without its usual code-field lookup. The project’s design notes describe it as:

Essentially ITC, but the code field is implied by tag bits in each thread cell rather than stored in the body.

The PDP-7 emulator that Claude and I made runs PDP-7 Forth like a bat out of hell. And the point is that if it's this good with antique esoteric PDP-7 assembly, then it's so much more proficient with modern assembly and high level languages that are orders of magnitude more widely represented in the training data like StackOverflow and GitHub, including TypeScript and Python.

https://youtu.be/lo8kdY-5i6c?t=867

OK, I held up my end of the bargain, and gave you the links to high quality AI generated code that you demanded, and even a video demo that shows and explains why it's so elegant and efficient and high quality. As you can see, the PDP-7 emulator also runs the original version of Unix flawlessly.

PDP-7 Forth is a small enough example to inspect, and I've explained the specific design choices I admire. If you think it's low-quality code, what is wrong with it? Can you optimize the inner loop any better, reducing it from 3 instructions to 2?

Before you complain you don't know PDP-7 assembly language: Neither did Mitch or I, but now thanks to Claude's help, we're learning a lot about it with hands-on experience, enough to make CPU and device emulators, an assembler, a disassembler, data visualization tools, improve and extend the Forth system itself, implement device emulators and drivers and apis and testers, and integrate PDP-7 assembly language libraries written in the late 1960's into it and run them. Can you do that yourself without AI in a couple of weeks, while having as much fun as Mitch and I did?

So why don't you review and criticize that code you asked for without using AI, tell me how you would have implemented it differently, then link me to some code you have written yourself without using AI that's at least as elegant as Mitch's PDP-7 Forth, and explain why.

DonHopkins··on Postgres 19 delayed after AI reviewers find more bugs than humans can fix
More bugs than humans can fix, but not more bugs than humans created.
DonHopkins··on Yet another way to invoke functions in JavaScript without parentheses
Unix is Dead! Wanna Fight?? (John C. Dvorak):

https://donhopkins.com/home/catalog/unix-haters/etc/unix-is-...

DonHopkins··on I designed a nose guard for my dog and gave it away. Now 500 dogs wear one
Or you could print out an ASCII table and tape it to the wall so you don't forget DLE = ^P = $10 = CHR$(16) = Data Link Escape.

https://commons.wikimedia.org/wiki/File:ASCII-Table-wide.svg

DonHopkins··on Wayland desktop for Linux with skeuomorphic design
In Brett Victor's 2011 essay, "A Brief Rant on the Future of Interaction Design", he laid out the foundation for his critique of skeuomorphic design. He believes hands are our future.

https://worrydream.com/ABriefRantOnTheFutureOfInteractionDes...

On the visual pretense: "Pictures Under Glass sacrifice all the tactile richness of working with our hands, offering instead a hokey visual facade."

On touchscreens mimicking real objects without haptics: "Pictures Under Glass is an interaction paradigm of permanent numbness. It's a Novocaine drip to the wrist. It denies our hands what they do best."

On why this design path is short-sighted: "To me, claiming that Pictures Under Glass is the future of interaction is like claiming that black-and-white is the future of photography. It's obviously a transitional technology. And the sooner we transition, the better."

DonHopkins··on Recreational Programming
My rule of thumb is that if you've been talking about how cool doing something would be for longer than it would take you to do it, you should "Shut Up 'N Play Yer Guitar".

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

Now that AI makes it so easy to play yer guitar, there's a lot more shutting up to do!

DonHopkins··on Recreational Programming
You must be holding it wrong, because I'm using AI to bring lots of old dead code back to life!

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

DonHopkins··on Recreational Programming
In my professional DevOps role I'm firefighting all the time, and in my professional programmer role I'm arsoning fires all the time, but I'd also love to hear how real firefighters apply programming skills!
DonHopkins··on Recreational Programming
"Recreational Programming" sounds like a fun legal alternative to "Medical Programming" that you don't need a prescription from your doctor to do.

I prefer the term "Pleasure Programming", to de-emphasize how addictive it is.

>Permission to build useless things.

I prefer the term "Ultimate Things", to de-emphasize how useless they are.

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

>The Italian artist Bruno Munari began building "useless machines" (macchine inutili) in the 1930s. He was a "third generation" Futurist and did not share the first generation's boundless enthusiasm for technology but sought to counter the threats of a world under machine rule by building machines that were artistic and unproductive.

>The version of the useless machine that became famous in information theory (basically a box with a simple switch which, when turned "on", causes a hand or lever to appear from inside the box that switches the machine "off" before disappearing inside the box again) appears to have been invented by MIT professor and artificial intelligence pioneer Marvin Minsky, while he was a graduate student at Bell Labs in 1952. Minsky dubbed his invention the "ultimate machine", but this nomenclature did not catch on. The device has also been called the "Leave Me Alone Box".

So here's a live demo of an ultimate thing I pleasure programmed:

https://hyperties.org/cabinet/ultimate/

What this is:

I've been using Claude to recreationally develop a PDP-7 and Type 340 vector graphics display emulator for the web browser, in order to run an early CAD system called PIXIE, which has the first known radial menus, driven by a light pen, developed at Cambridge in the late 1960's, whose 128 pages of PDP-7 assemblxy language source code the author Heinz Lemke scanned and sent me.

Once I got it working, I told Mitch Bradley about how much I wanted a Forth system for it. Mitch has written useful things like OpenFirmware and CForth, and I was his summer intern at Sun in 1987, where we had a fun time hacking his CForth into CADroid (a circuit editing system developed at LucasFilms) as an extension language and macro system.

https://github.com/MitchBradley/openfirmware

https://github.com/MitchBradley/cforth

http://www.art.net/~hopkins/Don/lang/forth.html

Since then, Mitch developed his Sun Forth system into OpenFirmware for the boot ROMs of systems like the Sparcstation, PowerPC Mac, and the OLPC. So naturally I thought it would be fun to run Forth on the same machine that ran PIXIE, mainly because I'd love to work together and hack Forth with Mitch again after all these years, but also because Forth was the perfect language for the PDP-7.

So then Mitch used Claude to whip up a PDP-7 Forth in one day, with Turtle Graphics!

https://github.com/MitchBradley/pdp7forth

https://hyperties.org/cabinet/forth/

It turns out that the PDP-7 instruction set is ideal for Forth. It has an "XCT" instruction for indirectly executing other instructions, which makes the Forth inner interpreter loop only require 3 instructions.

PDP-7 Forth — Mitch Bradley, 26 September 2026:

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

PDP-7 Forth, by Mitch Bradley:

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

PDP-7 Forth Source Code, NEXT: The Inner Interpreter:

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

  " --- NEXT: the inner interpreter ---
  " Only LAC/LAW-tag cells fall through to "dac i 012"; CAL/JMP-tag cells
  " transfer control elsewhere and never reach it.
  next:   xct i 010     " pre-increment IP, execute the thread cell
          dac i 012     " push AC (only reached by constant/variable cells)
          jmp next
Now that Forth runs like a bat out of hell, I'm hacking virtual hardware devices for the PDP-7, and controlling and visualizing them with Forth.

First I made an "Ultimate Machine" device for the PDP-7, inspired by Claud Shannon and Marvin Minsky, whose only purpose is to turn itself off!

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

Bruno Munari called it a "Useless Machine", but Minsky was more compassionate, and appreciated its purpose of turning itself off as being ultimately useful, so he renamed it the Ultimate Machine.

I think there are some deep implications to the halting problem, but I can't quite put my finger on it the way the Ultimate Machine puts its finger on its own off switch.

The Ultimate Machine emulator plugs into the PDP-7 emulator as a virtual device cabinet, which has its own device control IOTs that augment the PDP-7 instruction set.

DEC sold a lot of "plug-in instruction sets in a cabinet" like the Type 340 vector graphics display, its light pen, character generator, subroutine executer, advanced math instructions, etc.

https://gunkies.org/wiki/Type_340_Precision_Incremental_Disp...

The Ultimate Machine device, an emulator of device 56 with its registers, phases and IOTs:

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

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

Then I made a Forth program that draws an animation of the Ultimate Machine on the 340 display, with a switch activated by the light pen. It's not a "simulation" -- it's an actual interactive visual representation of the emulated Ultimate Machine device state that FORTH controls via IOT instructions, the same way it controls the 340 display and light pen!

The Forth 340 view, with the IOT words, the hand, lid and lamps, and the light-pen switch, so you can turn it on (and off) with the light pen (check out the tool tips the emulator user interface shows you when you point at the graphics):

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

Instead of halting there, for even more Turing completeness, I made a Turing Machine device, which is like the 340 display in that it not only adds device control IOT instructions, but also executes its own Turing Machine instructions and tape via DMA from of the same 18-bit core memory as the PDP-7 and 340 display.

The 340 display and the Turing Machine are both co-processors that execute their own instructions from the shared 18-bit core memory of the PDP-7, which generates code for them to execute, and controls them via IOT instructions.

The Turing Machine device issues an interrupt when its head page faults off the edge of the tape window in core, so the PDP-7 can implement virtual memory to support "infinite" tape.

Live Demo:

https://hyperties.org/cabinet/turing/

Turing Engine:

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

Forth => Turing Machine Compiler I made based on Christopher Cherniak's "TM*" courseware from the "Philosophy and Computers" course I took from him in the 1980's:

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

https://terpconnect.umd.edu/~cherniak/philcomp/

https://terpconnect.umd.edu/~cherniak/PhlCogSci.pdf

Ostensibly the real use is for education, but I actually did it because it was fun, and I felt like working with Mitch and programming Forth again.

Forth, the 340, and co-processors in one core: what the cabinet teaches:

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

Here's a demo video that tries to explain it:

PIXIE and FORTH on PDP-7 Cabinet Emulator with Type 340 Vector Graphics Display:

https://www.youtube.com/watch?v=lo8kdY-5i6c

DonHopkins··on The Four Colour Theorem: The first time machines mogged mathematicians
>[...] mogged [...]

Ixnay on the celinay ingolay.

DonHopkins··on The baffling intelligence of a single cell (2024)
David Goodsell is a great example of nominative determinism!

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

DonHopkins··on Now That Information Is Free, What's a College Campus For?
Food fights.

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

DonHopkins··on The baffling intelligence of a single cell (2024)
I love Goodsell’s paintings too: they make the molecular world feel simultaneously beautiful, crowded, wonderfully strange, and colorfully tasty.

This reminded me of Tim Davison’s LifeBrush, an interactive VR painting and simulation system explicitly inspired by Goodsell’s illustrations.

In his thesis, Davison describes using it to "structurally recreate, simulate and step inside" famous Goodsell illustrations -- the cytoskeleton demo is a striking example of a painting becoming a world you can enter and set in motion:

https://www.youtube.com/watch?v=6CsxADBpal0

https://hdl.handle.net/1880/111493

I first called LifeBrush "Emacs for Cytoplasm" in a Boids thread and asked Davison whether the molecular motion was slowed down. He replied that medium-sized proteins move around 5 m/s, and that LifeBrush deliberately slows and smooths Brownian motion for illustration. The code was open source; at the time it required a VR headset and had a clunky, research-grade interface.

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

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

https://github.com/timdecode/LifeBrush

The interaction is the magic: in the overview, a ribosome moves along mRNA as tRNA brings amino acids and a polypeptide chain grows. You can grab the ribosome and move it where you want, rather than wait for Brownian motion.

I described it as dragging the ribosome’s "lazy ass" through "tRNA pasta and mRNA meatballs." It’s a scientific illustration you can play with, not a literal molecular-dynamics visualization.

https://www.youtube.com/watch?v=5LBHRyGxLGI

https://www.youtube.com/watch?v=624F5iaCKco

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

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

Davison’s work has since grown into CellWalk, a guided, interactive tour through a bacterial cell, from the whole cell down to its atoms, for iPhone, iPad, and Apple Vision Pro.

And here the Goodsell connection is even more direct: Davison’s site credits David Goodsell, Ludovic Autin, and Martina Maritan with the CellWalk model and tour, based on their whole-cell paper. Davison is now CEO and cofounder of Ako Biotica, the company behind CellWalk.

https://timd.ca/

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

https://cellwalk.ca/

https://doi.org/10.1016/j.jmb.2021.167351

LifeBrush papers: the 2018 conference paper, followed by the 2019 Computers & Graphics article on painting, simulating, and visualizing dense biomolecular environments.

https://doi.org/10.1109/CW.2018.00017

https://doi.org/10.1016/j.cag.2019.05.006

DonHopkins··on Hackers activate automatic defrosting in supermarket fridges across Europe
You'll have a terrible time at Albert Heijn.

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

DonHopkins··on Secret of Orange Cats Revealed After 60-Year Search
Hey now, that's prejudice!

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

DonHopkins··on Cbirds: A flock of birds in your terminal
Craig also developed OpenSteer in 2002:

OpenSteer: Steering Behaviors for Autonomous Characters

https://github.com/meshula/OpenSteer

>OpenSteer is a C++ library for constructing steering behaviors for autonomous characters in games and animation. In addition to the library, OpenSteer provides an OpenGL-based application called OpenSteerDemo which demonstrates a variety of steering behaviors. The user can quickly prototype, visualize, annotate and debug new steering behaviors by writing a plug-in for OpenSteerDemo. [...]

>OpenSteer was initially developed by Craig Reynolds beginning in 2002 at the Research and Development group of Sony Computer Entertainment America. The OpenSteer authors wish to acknowledge the support of SCEA, SCEI and in particular these executives who had the foresight to release this code as open source for all to use: Shin'ichi Okamoto, Masa Chatani and Dominic Mallinson.

Also there's Blender's boids system, which has two main ancestors: Craig Reynolds' behavioral animation research, and Janne Karhu's rewrite of Blender's particle system. Its evolution turned the classic flocking model into an animator-controlled toolkit for flocks, herds, pursuit, and simple battles.

DonHopkins··on Attack of the Vibe Coded Photoshop Clones
Cloning Photoshop is such an underwhelmingly unoriginal and unambitious design goal, like photocopying a Roy Lichtenstein painting, or cloning MS-DOS.

Treating Photoshop's interface as the destination squanders the opportunity to rethink how people create images.

"Things seem to hang on in computing just because they work a little bit." -Alan Kay

From a personal email about MVC and Morphic, published here:

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

"It is an unworthy design objective to aim for anything less than trying to do to the Macintosh what the Macintosh did to the previous state of the art." -Bill Buxton

The "Natural" Language of Interaction: A Perspective on Non-Verbal Dialogues, INFOR: Canadian Journal of Operations Research and Information Processing, 26(4), 1988, pp. 428–438.

https://www.billbuxton.com/natural.html

THE MACINTOSH AS VICTIM

Before going too much further, it is probably worth making a few comments about my approach and my examples. As will become pretty evident, the Apple Macintosh takes a bit of a beating in what follows. Some readers may view this as evidence of contempt for its design. From my perspective, it is evidence of respect. Let me explain.

User interface design today is plagued by an unhealthy degree of complacency. We live in a world of copy-cat unimaginative interface products, where major manufacturers put out double-paged colour spreads in Business Week announcing "... our system's user interface is as easy to use as the most easy to use microcomputer [i.e., the Mac]" (or words to that effect). In what other industry can you get away with stating that you're as good as the competition, rather than better? Especially when the competition's product is over 4 years old!

The best ideas are the most dangerous, since they take hold and are the hardest to change. Hence, the Macintosh is dangerous to the progress of user interfaces precisely because it was so well done! Designers seem to be viewing it as a measure of success rather than as a point of departure. Consequently, it runs the risk of becoming the Cobol of the 90's.

I criticize the Macintosh precisely because it is held in such high regard. It is one of the few worthy targets. If I can make the point that there are other design options, and that these options appear to have a lot of potential, then I may help wake people up to the fact that it is an unworthy design objective to aim for anything less than trying to do to the Macintosh what the Macintosh did to the previous state-of-the-art.

Enough of the sermon. Let's leave the pulpit for some concrete examples.

← PreviousPage 4 of 34Next →