The Dual Phases of Computation: Edit Time (Static) vs. Runtime (Dynamic)
How static human-readable code is assembled into memory words and brought to life by the system clock
Look at the status bar at the top of the memory editor: - 🟢 EDIT MODE (Cycle 0): You can freely modify instructions and numbers. - 🔒 RUNNING MODE (Cycle 1+): Memory is locked during/after execution. Press [RESET] at the bottom anytime to return to 🟢 EDIT MODE.
🎯 Your Task 1. While in 🟢 EDIT MODE, click the + button on the highlighted right-hand number (B) of Address 0000 to change it from 0 to 1. 2. Press [STEP] once to verify your change!
1. The Static Blueprint (Edit Mode) vs. The Living Universe (Running Mode)
In Step 3, you modified the right-hand value of Address 0000 from 0 to 1 while in "🟢 EDIT MODE (Cycle 0)", and then pressed [STEP] to transition into "🔒 RUNNING MODE (Cycle 1+)". This modal transition is not merely a user-interface convenience—it directly mirrors the two fundamental phases of software existence in computer science: Static Time (Edit/Compile Time) and Dynamic Time (Runtime).
During Edit Mode at Cycle 0, the universe's clock is frozen. As you click the "+" button to change a value from 0 to 1, an internal assembler parses your change in real time and places the corresponding instruction word directly into Memory Cell 0000. Think of this phase as arranging the gears of a clockwork organism with tweezers before winding the spring.
The moment you press [STEP] or [PLAY], the system enters Runtime. The human creator's tweezers are withdrawn, the memory space is locked against external interference, and the laws of the virtual CPU take over completely. In modern operating systems, this transition corresponds to the moment the kernel loader maps an executable binary into virtual memory pages and transfers control to the program's entry point.
[🟢 EDIT MODE : Cycle 0] Human edits source ──► Assembler writes Initial Memory State
│
Press [STEP] / [PLAY]
▼
[🔒 RUNNING MODE : Cycle 1+] CPU Clock ticks ──► Program mutates its own Memory State2. How Real-Time Static Assembly Preview Works
If you look closely at the workbench while in Edit Mode (Cycle 0), you will notice that changing a number immediately updates the memory representation even before you press [STEP].
In traditional systems programming (such as C or Rust), editing source code and loading it into memory are separated by a lengthy toolchain: you write text in an editor, invoke a compiler and assembler to translate that text into binary machine code, and finally ask the operating system's loader to map those binary words into RAM.
In this interactive laboratory, the Redcode-94 assembler and the MARS memory loader run continuously in the background while you are in Edit Mode. Every time you increment a number or change an opcode at Cycle 0, the system re-assembles your warrior and re-initializes the 800-cell memory core on the fly. This real-time static compilation is what allows the workbench to draw predictive target arrows showing exactly where your instructions will strike before a single cycle of time has elapsed.
3. How Initial Parameters Shape Computational Destiny
In this mission, you changed the right-hand value of "DAT.F #0, #0" at Address 0000 to "1" and advanced the clock by one step. Even though the execution pointer immediately halted upon executing the DAT cell, the memory inspection confirmed that Cell 0000 retained the B-value of 1 that you engineered at Cycle 0, fulfilling the mission objective.
In both autonomous robotics and CoreWar, the human designer's direct control ends at Cycle 0. Once a battle begins in the Arena, you cannot reach in to rescue a struggling program. Everything your digital organism will ever achieve—how fast it scans, where it drops bombs, and how it replicates—depends entirely on the initial instructions and initial parameters you craft during Edit Mode. In dynamical systems theory and cellular automata (such as Conway's Game of Life), this initial memory configuration is called the "Seed" or "Boundary Condition." A change as small as incrementing a single operand from 0 to 1 at Cycle 0 can mean the difference between an organism that immediately perishes and an organism that colonizes the entire memory array. Learning to respect the boundary between static design time and dynamic execution time is the first milestone of every systems programmer.
🔒 MISSION CLEAR Unlocks the Full Lecture Note
Complete the experiment in the simulator above to automatically unlock the full deep-dive article—or click below to read the full text immediately.