Bendix G-15

Embedding

The Bendix G-15 here is authored from scratch in one small file, bendix-g15.js. It is a plain global — G15.create(canvas) returns a machine object whose whole state is ordinary JavaScript (the drum lines are arrays of 29-bit words; AR, ID, PN and MQ are plain numbers), so the debugger reaches straight into it with no wasm heap or hidden loop. A tiny assembler, G15.assemble, turns a readable listing into a drum image (commands laid out along a command line, constants pre-loaded on data lines).

Boot. Create the machine on a <canvas>, assemble and load a program, then run your own loop built on g15.step() (execute exactly one command):

var g15 = G15.create(canvas);
var prog = G15.assemble({
  cmdLine: 1, start: 0,
  code: [
    { op: 'TR', s: 20, d: 28, t: 1 },   // AR := line20[1] (=10)
    { label: 'loop', op: 'TYPE' },        // type AR on the typewriter
    { op: 'SU', s: 20, d: 28, t: 0 },   // AR := AR - line20[0] (=1)
    { op: 'TEST', br: 'loop' },          // if AR>0 go to loop, else fall through
    { op: 'CR' }, { op: 'HALT' }
  ],
  data: { 20: { 0: 1, 1: 10 } }       // constants on fast line 20
});
g15.load(prog);
(function loop(){
  var r = g15.step();               // 'ok' | 'stop'
  g15.render();
  if (r !== 'stop') requestAnimationFrame(loop);
})();

The machine is plain fields. Everything the debugger needs is live on the object: g15.step() executes one command; g15.ar/id/pn/mq are the working registers; g15.cmdLine / g15.cc / g15.next are the command line and the current / next command word-times (the one-plus-one link); g15.wt is the drum word-time; g15.peek(a)/g15.poke(a,v) read and write a drum word side-effect-free (linear address = line×128 + word); and g15.onWrite(a,v) fires on every drum write, which the boot uses for watchpoints.

Debugger integration

The plug-in bendix-g15-debug.js calls EmuKit.defineMachine against the live core. Because the whole machine is ordinary JavaScript, no wrapping is needed:

• Registers. The accumulator AR, the double registers ID / PN / MQ, the present command word CMD, the CMDLINE, the current command word-time CC and the one-plus-one next word-time N, the drum word-time WT, and the SIGN (last AR-sign test) and HALT flags. Each set() writes straight back into the core and re-renders.
• Memory. One chip, the drum, addressed linearly as line×128 + word and read side-effect-free through peek. The disasm view runs the new g15 decoder; bits shows the raw 29-bit pattern; hex shows bytes.
• The decoder. debugger/src/cpus/g15.js registers decoder g15. It reads the true 29-bit command word off the live machine and splits it into prefix / timing T / next-command N / characteristic C / source S / destination D, printing e.g. SU AR→AR N=3 or the special-command form TYPE AR N=2 and the conditional TEST AR ?→1 N=4.
• Transport. The boot owns the run loop, so pause/resume, single-command step, execution breakpoints (a host-side Set of command word-times checked before each step()) and write watchpoints (checked inside onWrite) all work with no change to the core.

Architecture

The Bendix G-15 (Bendix Aviation, 1956) was designed by Harry Huskey, who had worked with Turing on the Pilot ACE. Built from roughly 450 vacuum tubes with a magnetic-drum memory and a bit-serial arithmetic unit, it was small and cheap enough for one person to operate — an early "personal" computer. This authored core reproduces its defining ideas:

• Drum memory of 29-bit words. Twenty long lines (channels) of 108 words each, four fast 4-word lines ("revolvers", 20–23), and the double-length registers exposed as lines — MQ (24), ID (25), PN (26) and the one-word accumulator AR (28). A word is addressed by (line, word-time) as the drum rotates.
• One-plus-one / optimal coding. Every command word carries the drum word-time N of the next command, so the programmer places the next command just past this one's drum latency. The command line and the walking amber column show this on the drum.
• Source→destination transfers with a "characteristic". Each command names a source line S, a destination line D and a 2-bit characteristic C selecting the arithmetic: TR copy, AD add-to-AR, SU subtract-from-AR, AV absolute value. Destination line 31 is the special-command line: S then selects halt, type-a-register, carriage return, or a conditional test on the sign of AR.
• Typewriter I/O. Results are typed onto the paper at the right; the console keypad stands in for the operator's typewriter.

A 29-bit command word packs a prefix bit P, a 7-bit timing number T (which word-time the transfer refers to), a 7-bit next-command time N, a 2-bit characteristic C, a 5-bit source S, a 5-bit destination D, and the double-precision and breakpoint bits.

The shared g15 decoder turns each word back into these forms in the disassembly, so you can watch the fetch-execute cycle and the one-plus-one drum linking one command at a time. (Authored timing simplification: the real G-15 is bit-serial, streaming a transfer between word-times and deferring until the drum reaches time T; this core steps at word level — one command to completion per step() — while still advancing the drum word-time to N so the optimal coding and rotation stay real and visible.)