Objects clone from prototypes, not instances from classes
"Objects all the way down."
The philosophy of prototype-based inheritance: no classes, just concrete examples that you clone and modify.
This skill is directly inspired by Self. In MOOLLM, Self is one of this skill’s prototypes: the schemapedia self mechanism names that parent lineage (Ungar, Smith, and collaborators). The same Delegation Object Protocol applies to skills as to room instances: an ordered PROTOTYPES.yml can list several parent skills—Self is not the only possible parent. Because prototype inherits from Self, it already follows the rules that let any MOOLLM object inherit from multiple prototypes (local wins, then each parent in order, first match wins).
Classical inheritance says:
But this creates problems:
Prototype-based inheritance says:
Everything is concrete. Everything exists.
Self is a universal object machine: a minimal language of objects, slots, and delegation from which you can implement or host other object systems—classes (as conventions on top of prototypes), CLOS-style generic functions and method combination, generic dispatch lineages (ScriptX, Dylan, and related multimethod designs), COM / OLE / ActiveX-style component object models, PostScript Dictionary Stack NeWS "class.ps" Objects, JSON (maps of keys to values as object-shaped data), YAML Jazz (semantic comments beside the parsed tree in MOOLLM’s notation layer), and more. Those systems are not the same mechanism as Self; they are targets you model, embed, or bridge—Self and prototype delegation stay the bedrock.
Objects are collections of slots:
cat: (|
name <- "Terpie".
color <- "orange".
meow = (| | "Meow!" |).
parent* = catPrototype.
|)
name, color — data slotsmeow — method slotparent* — parent slot (for delegation)When you send a message to an object:
To create a new cat:
newCat := cat clone.
newCat name: "Stroopwafel".
newCat color: "tabby".
The new cat:
name and color slotsmeow to the prototypeMOOLLM implements prototype inheritance via the Delegation Object Protocol (DOP):
# In an instance directory
prototypes:
- path: "skills/room"
- path: "skills/adventure"
resolution:
strategy: "first-match-wins"
examples/adventure-4/pub/
├── ROOM.yml # Local override (shadows prototype)
├── PROTOTYPES.yml # Points to skills/room
├── state/ # Local-only state
│ └── visitors.yml
└── (missing files delegate to skills/room/)
LLMs don't compute inheritance algorithms. They navigate files.
Prototype-based inheritance is LLM-friendly because:
From the abstract of Self: The Power of Simplicity (Ungar & Smith, OOPSLA ’87):
Self is an object-oriented language for exploratory programming based on a small number of simple and concrete ideas: prototypes, slots, and behavior.
Source: Self bibliography · PDF
Self taught us that simplicity wins:
MOOLLM applies this: directories are objects, files are slots, resolution is delegation.
| Year | Event |
|---|---|
| 1986 | Ungar & Smith begin Self at Xerox PARC |
| 1987 | Self paper published |
| 1991 | Self 2.0 with compilation |
| 1995 | JavaScript created (heavily Self-influenced) |
| 2024 | MOOLLM applies Self to LLM filesystems |
