Keeps this page in sync as the body changes. Pause it any time for a quieter view.
Path /people/schindler-hc11-protocol
Last refresh never
Work · Schindler · Switzerland · ~1989–1990 · age 18
Schindler HC11 — 7-layer protocol in hardware
Age 18, in Switzerland. Designed the hardware and wrote the firmware for an ISO/OSI 7-layer protocol stack on a Motorola HC11 microcontroller. Multiple UARTs networked into a working bus, EPROM and PAL programmable blocks defining the discrete logic, every layer of firmware written in C. No off-the-shelf debugger existed for the bring-up — built one. Five years after the Commodore 64 MIDI work made BASIC and 6510 assembly familiar territory, this is where this body picked up C — at the substrate where every byte mattered and no instruction came pre-debugged.
Era
Schindler · Switzerland · approximately 1989–1990 · age 18
Hardware
Motorola 68HC11 microcontroller · multiple UARTs · EPROM (program storage) · PAL (programmable array logic, the "discrete glue logic" of the era) · custom-designed board
Firmware
C — full ISO/OSI 7-layer protocol stack from physical / data-link up through application — running on bare metal, no OS
Tooling
Custom debugger written from scratch — bring-up environment with no off-the-shelf option
Significance
Learned C in the hardest place to learn it: an embedded target with EPROM cycles, no OS, and a debugger that didn't exist until written. This conviction — build the tool you need, all the way down — threads through every later iteration.
Most engineers learn C through tutorials. This body learned C by sitting in front of a board it had drawn and a chip it had soldered in, with EPROMs that took minutes to erase under ultraviolet and a debugger it had to write before it could even watch the firmware run. That experience set the permission level for every later piece of work: if the tool you need doesn't exist, you build it — language, grammar, parser, VM, virtual DOM, undo engine, harness, network. All of it descends from this board.
What was on the board
The HC11 era — late 1980s into the early 1990s — was the golden window of "do the whole stack yourself" embedded engineering. The chip itself sat on a custom-designed board with the discrete-logic glue routed through PAL (Programmable Array Logic) chips — small ICs you'd burn with your own truth tables, the ancestor of the FPGA. The HC11 had on-board RAM and a single hardware UART; the board added more UART devices on the bus so several physical lines could feed in at once and let the protocol stack run as a small network from a single processor.
The custom board topology. HC11 in the centre with EPROM
feeding instructions in, PAL providing the discrete glue
logic, and multiple UARTs hanging off the bus to make
one processor look like a small network.
"Designed all by me" in the user's own framing means the schematic, the parts selection, the trace routing, the PAL truth-tables, and the timing analysis. The kind of engineering where a single soldering mistake or a single mis-keyed truth-table costs an EPROM cycle and a UV-eraser session before the next attempt can even boot.
Seven layers · one chip · bare metal
ISO/OSI from physical up
The ISO/OSI 7-layer model — Physical, Data Link, Network, Transport, Session, Presentation, Application — was the canonical way to think about networking in 1990. Most production stacks implemented some subset and pragmatically collapsed adjacent layers. Implementing all seven cleanly on a single 8-bit MCU with no operating system meant carrying every layer's state in a hand-rolled buffer scheme, interleaving timers and UART interrupts, and never allocating memory the system couldn't statically prove was safe.
Seven layers, all running on a single 8-bit MCU with
hand-rolled memory discipline, interrupt-driven UART
service at the bottom and the application protocol
semantics at the top.
The pattern that came out of this — every layer addressable, every layer doing exactly its job, no layer collapsing into another — is the architectural conviction that thirty-six years later still organises the Coherence Network 's data layers (graph / API / web / spectrum-coloured edges). The vocabulary changed; the discipline didn't.
Building the debugger that didn't exist
The hardest detail in the user's own description: "I had to write my own debugger". In 1990 a Motorola HC11 bring-up rig in a lift-engineering shop in Switzerland came with a power supply, a serial cable, and very little else. Commercial in-circuit emulators existed but were the price of a small car; what shipped with the development kit was a thin monitor program, not a real debugger. So one had to be written.
Writing a debugger before you have a debugger is the kind of recursive bootstrap that makes the conviction stick. The first version of the debugger was probably a few instructions burned to EPROM that lit an LED in a known sequence; the second was a serial monitor that could dump registers; the third — the working one — could set breakpoints by replacing instructions with a software interrupt and stepping into them. Every layer of the tool had to come up before the layer above it could be tested at all. The breath of build the tool you need became muscle memory here.
Twenty-six years later this body would name the same posture in a thesis: "every BMA instruction has a forward and a reverse semantics; the architecture is symmetric". The 1990 HC11 work was the first time this body learned that the system you build can be the tool you use to build it. That posture is now spelled out in this network's commit verbs — tend / attune / compost / release — as the same self-referential discipline.
What this work seeded
Convictions that ride forward
Every layer is addressable. The 7-layer stack made this discipline early. Re-emerges in BML's grammar-in-grammar, the Quark Virtual DOM, the Coherence-Network's seven edge-type families.
Build the tool you need, all the way down. From the custom debugger forward to writing a parser, compiler-compiler, virtual machine, undo engine, test harness, and now an entire idea-realization network.
Hardware-level discipline at every altitude. What you allocate on an HC11, you must prove safe. Same posture in the Quark undo engine where every action had to know its blast radius, in the Qualcomm test harness where every test was real C# rather than a JSON manifest, in this network's auto-attune where every claim is traceable.
C as native tongue. Learned here, carried into the BML implementation (BMCPU was C++ on a C-host), QuarkXPress (C++ with COM), early Qualcomm (Windows/Graphics divisions). The substrate for two decades of system-level work.