Design, tech, engineering and science. Head of Design and User Research.
Public
Edited
Nov 23, 2024
memory
accumulator
function test() {
return run(
[0, 1],
["add", 1],
["storeAtPointer"],
["addFromPointer"],
["inc"],
["storeAtPointer"],
["addFromPointer"],
["inc"],
["storeAtPointer"],
["addFromPointer"],
["inc"],
["storeAtPointer"],
["addFromPointer"],
["inc"],
["storeAtPointer"],
["addFromPointer"],
["inc"],
["storeAtPointer"],
["addFromPointer"],
["inc"],
["storeAtPointer"],
["addFromPointer"],
["inc"],
["storeAtPointer"]
);
}
bits = 32
hz = 10 // cycles per second
maxCycles = 128
instructions = [
loadN,
loadFrom,
loadFromPointer,
storeAt,
storeAtPointer,
add,
addFrom,
addFromPointer,
sub,
subFrom,
subFromPointer,
inc,
dec,
jumpTo
]
mutable running = false
mutable cycle = 0
mutable currentInstructionIndex = 0
mutable currentInstructionSet = []
function loadInstructionSet (...args) {
mutable currentInstructionSet = normalizeInstructionSet(...args)
}
mutable log = []
function writeIntoLog (...args) {
mutable log = [args, ...mutable log]
}
function run(...args) {
// Conveniently load new instruction set
if (args.length) {
loadInstructionSet(...args);
}
reset();
mutable cycle = 0;
return play();
}
function play() {
mutable running = true;
// Execute instruction set
// NOTE: absolute failsafe of 100 k cycles
// Because no computer in the world would be able to run for so long without failing
let i = 0;
while (
mutable running &&
mutable cycle < maxCycles &&
mutable currentInstructionSet[mutable currentInstructionIndex] &&
i < (100 * 1000)
) {
// Execute individual instruction
runCycle();
mutable currentInstructionIndex = mutable currentInstructionIndex + 1;
mutable cycle = mutable cycle + 1;
i++;
}
mutable running = false;
return mutable accumulator;
}
function pause() {
mutable running = false;
}
function reset() {
mutable currentInstructionIndex = 0;
mutable accumulator = 0;
mutable pointer = 0;
mutable memory = Array(bits);
}
function runCycle() {
// Instruction can be string or number, and an optional argument
const instruction = mutable currentInstructionSet[
mutable currentInstructionIndex
];
// We get the actual instruction function here
const f = getInstruction(instruction[0]);
// Catch bad instruction sets
if (!f) {
throw new Error("Invalid instruction", instruction);
}
writeIntoLog(...instruction)
// Pass on one argument to instruction function
f(instruction[1]);
}
mutable accumulator = 0
mutable pointer = 0
mutable memory = Array(bits)
function inc () {
mutable pointer = pos(mutable pointer + 1)
}
function dec () {
mutable pointer = pos(mutable pointer - 1)
}
// Jump to position in instruction set
// FIXME: How to use jump without causing infinite loops?
function jumpTo(i) {
mutable currentInstructionIndex = i % mutable currentInstructionSet.length;
}
function add (n) {
mutable accumulator += n
}
function addFrom (i) {
return add(mutable memory[pos(i)])
}
function addFromPointer () {
return add(mutable memory[mutable pointer])
}
function sub (n) {
mutable accumulator -= n
}
function subFrom (i) {
return sub(mutable memory[pos(i)])
}
function subFromPointer () {
return sub(mutable memory[mutable pointer])
}
function loadN (n) {
mutable accumulator = n
}
function loadFrom (i) {
return loadN(mutable memory[pos(i)])
}
function loadFromPointer () {
return loadFrom(mutable pointer)
}
function storeAt (i) {
mutable memory[i] = mutable accumulator
// https://talk.observablehq.com/t/mutable-push-to-array/4234
mutable memory = mutable memory
}
function storeAtPointer () {
return storeAt(mutable pointer)
}
[0, 1, 127, 128, 129, 513].map(pos)
Purpose-built for displays of data
Observable is your go-to platform for exploring data and creating expressive data visualizations. Use reactive JavaScript notebooks for prototyping and a collaborative canvas for visual data exploration and dashboard creation.
