summaryrefslogtreecommitdiff
path: root/design/motion.md
diff options
context:
space:
mode:
authorGabriel Schneider <[email protected]>2026-11-11 12:08:00 -0300
committerGabriel Schneider <[email protected]>2026-11-11 12:49:15 -0300
commit4c7dcadeddaa50fb52fd44a2cc71df1f570e092a (patch)
treef28491261b55b81638b4bb1d1091b80cec407abe /design/motion.md
parent92aea44cb7dd0a7995327d2f276563b8058afbc9 (diff)
downloadcomputeranim-4c7dcadeddaa50fb52fd44a2cc71df1f570e092a.tar.gz
computeranim-4c7dcadeddaa50fb52fd44a2cc71df1f570e092a.zip
design: the address space said with less; a word read low byte first; aligned in two forms
From the user. The address space is a slim bar to true scale with its two ends written, each cluster enlarged once beside it, and every band carrying the addresses where it starts and stops and its size; no rulers, no factors. The stack's bytes on screen are tied to their place in it. regroup is drawn: a word's eight bytes fly out low byte first and land reversed as its sixteen digits. aligned has two forms a scene asks for by name: interleaved, a line as the head of its instructions, and columns, the source beside them with each line as tall as its run. Co-Authored-By: Claude Fable 5.2 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
Diffstat (limited to 'design/motion.md')
-rw-r--r--design/motion.md90
1 files changed, 78 insertions, 12 deletions
diff --git a/design/motion.md b/design/motion.md
index bc58c6f..a747e9d 100644
--- a/design/motion.md
+++ b/design/motion.md
@@ -724,6 +724,68 @@ Each cell keeps its old digits, faint, until its own landing. Its bar
for any pointer; the other nodes glide to their new places 18 f after the
arrow lands.
+### A word read
+
+`regroup`, walked, on the return address's eight bytes (`b0 18 00 01 00 00
+00 00` at `7fffffffece8`, [mock 37](mock/37-regroup.png)), from the beat's
+step. The camera is at x2 on the dump the whole time; the dump is built
+where the stack panel will stand. What the viewer must leave with: which
+byte is the low one (the first in memory), the order they are read in (the
+last first), and that the sixteen digits are the same eight bytes.
+
+| Frames | |
+| --- | --- |
+| 0 to 18 | sixteen a row to eight: every row glides down as many rows as there are rows above it, making room (`glide`) |
+| 18 to 30 | each right half goes down a row, under its left half (`glide`) |
+| 30 to 48 | and left, to the bytes' column (`glide`); the new rows' addresses fade in, 36 to 48. Down, then left: a half never passes over a byte |
+| 48 to 66 | the veil over every row but the walked one |
+| 66 to 92 | its offsets fade in under its bytes, `+0` to `+7`, left to right, 2 f apart, 12 f each (`column`) |
+| 84 to 96 | `low byte` under `+0`, `high byte` under `+7` |
+| 96 to 108 | still: the question is on screen |
+| 108 to 186 | the bytes fly, the low byte first: byte k lifts at 108 + 6k and lands at 144 + 6k, 36 f, `glide`: straight up off its place, over on an arc a quarter as high as it is long (34 to 120), straight down onto its pair's place in the word's field, the pairs 30 apart and ranged right. The arcs nest (the low byte's the highest and longest) and never cross; each byte is bright and bold in the air. Its offset goes with it and lands under it, so the field reads `+7` to `+0`; `low byte` and `high byte` go with theirs. Its place in the dump takes a faint copy, fading in from a third of the flight (12 f): nothing is ever printed over it |
+| 192 to 204 | the gaps close: the pairs glide right to sixteen digits, `00000000010018b0` (12 f, `glide`) |
+| 204 to 216 | the offsets and the two labels fade; a faint bracket under the nine zeros in front, `zeros in front`, fades in |
+| 216 to 228 | still |
+| 228 to 240 | the zeros and their bracket fade: `10018b0`, ranged right where it was |
+| 240 to 270 | still |
+| 270 to 288 | the veil lifts |
+| 288 to 386 | the other fifteen at a run: rows top down, 6 f apart, each word fading in (8 f) as its bytes dim (8 f) |
+
+The bytes fly, not copies of them, so that at the lift there is nothing
+under them; the faint bytes left in the dump are what stays of where they
+were. Eight flights at once would cross; one after another, low byte first,
+they nest, and the order of the landing is the order of the reading.
+
+### The address space enlarged
+
+The whole first: the bar (18 f), its ends' addresses and its size (12
+f), the 2-unit lines at its ends (12 f). Then `enlarge`, a box a cluster,
+from its start e:
+
+| Frames | |
+| --- | --- |
+| e to e+6 | the cluster's line on the whole framed bright (2 units, 3 out) |
+| e+6 to e+78 | the ride, `glide`: the box's left corners travel the magnification's two lines from the line to their places, the lines drawn behind them; the box is as tall as they are apart and goes from the bar's width to its own; its bands are drawn at its scale all the way, so the hairline swells, a mapping stays a 2-unit line until it is taller, and the gaps between them open (the 1.3 MiB under the loader appears as page) |
+| e+66 to e+78 | the bright frame on the line fades |
+| e+78 to e+90 | the box's page lines fade in |
+| e+90 on | its names, rows top down, 2 f apart: an edge's leader draws from the box (6 f), then its address fades in (12 f); a band's row fades in (12 f); a file's bracket and name with its last row |
+
+The stack's box rides first, the libraries' at e+78 (as the stack's
+lands), the program's at e+156: three rides one after another, never two
+at once, in address order, so the eye goes down the stage with them. The
+camera is still (x1): the whole stays on screen, and the box is the
+magnification's own picture, not a camera's.
+
+A dump's place (the introduction), from its step l, after the last box's
+names:
+
+| Frames | |
+| --- | --- |
+| l to l+6 | the `tie` bracket on the dump's rows, in the stack's ink |
+| l+6 to l+42 | the `link` draws from the bracket's top, head first, `standard`: up into the top margin, across the gutter and the program column, down onto the stack's box |
+| l+42 to l+54 | the head lands; the stack's band framed bright (6 f in, 12 out) |
+| the next beat | the link and the bracket quiet to standing (24 f, `glide`, 60% toward the page) and stay while the dump and the space share the frame |
+
### The camera
In, to x2:
@@ -1244,36 +1306,40 @@ The frame built from its bytes up, on the recording mocks 9 to 21 use
(`targets/list`, stopped at the load in `reverse`). Three short scenes,
not one: each is a chapter with its own opening and its own last picture,
which the next opens from, so a viewer can stop between them; together
-104 s. Each view grows out of the rawer thing under it, in the order the
+124 s. Each view grows out of the rawer thing under it, in the order the
direction rule gives: memory first (the deepest), then the stack that is
made of it, then the code that acts on it, and the idea last, at the top.
Nothing cuts to a finished panel: the same bytes become the word, the
same word the row, the same row the slot.
**Where the parts are.** Each part is built in the place it has in the
-finished frame, never centred and moved later; the camera frames the part
-being built (x2 for the first bytes, x1.5 for the words and the address
-space, x1.25 for the stack and registers), so the frame's empty parts are
+finished frame, never centred and moved later: the bytes where the stack
+will stand (the state column), the address space in the program column,
+which is empty until the code comes. The camera frames the part being
+built (x2 for the bytes and the words, x1 for the address space beside
+them, x1.25 for the stack and registers), so the frame's empty parts are
out of shot until the parts that fill them come. An introduction earns
that emptiness; nothing else does. A panel's tag and rule come last
(`frame up`): first the rows, then what they are called.
-**I. Memory** (43.9 s)
+**I. Memory** (63.8 s)
| Lands | Leaves | Caption | Step, at | What plays |
| --- | --- | --- | --- | --- |
| 78 | 474 | A running program is bytes in memory. These are 128 of them, at the top of the stack. | 198 | the bytes fade in a row at a time (12 f, 2 f apart), no ink, the addresses faint; the camera at x2 (mock 29) |
-| 492 | 852 | Eight bytes make a word, stored low byte first: read right to left. | 552 | `regroup` on the first word, walked; the other fifteen at a run |
-| 870 | 1219 | Some words are addresses: numbers that name a place in this same memory. | 930 | one word framed as read, `10018b0` |
-| 1237 | 1665 | The places are the program's mappings: its code, its data, the heap, the libraries, the stack. | 1297 | `segments` builds beside the words, a row at a time, top down; the camera out to x1.5 |
-| 1683 | 2115 | A word takes the ink of the mapping it points into. That is where every colour here comes from. | 1743 | `ink`, word by word, 2 f apart, each with its mapping framed (mock 30) |
-| 2133 | 2511 | Follow an address and you reach another word: the arrow, and the chain it makes. | 2193 | three words grow their chains (`extend`), walked |
+| 492 | 986 | Eight bytes make a word, stored low byte first: the byte at the lowest address is the word's last two digits. | 552 | `regroup`: sixteen a row to eight, the return address walked, the other fifteen at a run, 552 to 938 ([chart](#a-word-read), mock 37) |
+| 1004 | 1360 | Some words are addresses: numbers that name a place in this same memory. | 1064 | one word framed as read, `10018b0` |
+| 1378 | 1840 | The places are its mappings, drawn to scale: 128 TiB, and all that is mapped is a hairline at each end. | 1438 | the camera out to x1 (72 f, `glide`); `segments`' whole builds in the program column, 1510 to 1552 |
+| 1858 | 2334 | Enlarged, each end has names: the stack and the libraries at the top, the program and its heap at the foot. | 1918 | `enlarge`, the stack's box, the libraries' at 1996, the program's at 2074, their names to about 2210 ([chart](#the-address-space-enlarged)) |
+| 2352 | 2846 | These 128 bytes are here. If the bar were the Eiffel Tower, they would be about an atom thick, at its very top. | 2412 | the dump's place: its bracket, the `link` over the top onto the stack's box, 2412 to 2466 |
+| 2864 | 3308 | A word takes the ink of the mapping it points into: 10018b0 is in list's code, 1001000 to 1002000. | 2924 | `ink` on the return address, walked: its digits, its band and its row framed (an echo), held to 3002; the rest at a run, 2 f apart; the link quiets (mock 30) |
+| 3326 | 3708 | Follow an address and you reach another word: the arrow, and the chain it makes. | 3386 | the words glide to their field's left (24 f, `glide`) to give their chains room; three grow their chains (`extend`), walked |
**II. The stack** (27.7 s), opening on I's last picture
| Lands | Leaves | Caption | Step, at | What plays |
| --- | --- | --- | --- | --- |
-| 78 | 478 | rsp holds the address of the top of the stack, this word. A push moves it down a word. | 198 | rsp's row arrives above, its pin lands on the top word; from the recording by instruction, the `push rbp` of `reverse`'s prologue replayed: rsp struck, the window sliding a slot |
+| 78 | 478 | rsp holds the address of the top of the stack, this word. A push moves it down a word. | 198 | the address space and the dump's link fade (18 f) as the camera goes to x1.25 on the state column; rsp's row arrives above, its pin lands on the top word; from the recording by instruction, the `push rbp` of `reverse`'s prologue replayed: rsp struck, the window sliding a slot |
| 496 | 791 | A call pushes the address to come back to: here, main+80. | 556 | the word `10018b0 main+80` framed; the offsets (`column`) |
| 809 | 1198 | A function's words are its frame: the caller's rbp saved, its locals, the way back. | 869 | roles (`column`), the spans, the rbp pin; the stack's tag (`frame up`) |
| 1216 | 1540 | The registers are the other place values live: seventeen of them. | 1276 | the registers built a row at a time over the stack, top down, then their tag, its legend the inks of I (mock 31) |
@@ -1283,7 +1349,7 @@ that emptiness; nothing else does. A panel's tag and rule come last
| Lands | Leaves | Caption | Step, at | What plays |
| --- | --- | --- | --- | --- |
| 78 | 378 | Code is bytes too. 48 8b 7f 08 is one instruction. | 198 | the code's bytes as a dump row in code's ink; one instruction's bytes framed |
-| 396 | 796 | Decoded: mov rdi, [rdi + 8]. It came from line 21: each line sits level with its code. | 456 | `decode`, the instruction walked and its neighbours at a run; the source's lines arrive level with their runs: `aligned` (mock 32) |
+| 396 | 796 | Decoded: mov rdi, [rdi + 8]. It came from line 21: each line sits level with its code. | 456 | `decode`, the instruction walked and its neighbours at a run; the source's lines arrive level with their runs: `aligned`, `interleaved` (mock 32) |
| 814 | 1160 | rdi pointed at a list node on the heap. Its bytes, and drawn, the node. | 874 | `stack`: the aligned columns become the program column; the heap's dump arrives in the band's right half, then the nodes drawn from it (`establish`) |
| 1178 | 1491 | This is the whole frame. Every view in it is these same bytes. | 1238 | the camera out to x1; the minimap draws itself last: the working frame of mock 9, assembled |
| 1509 | 1809 | And all of it at once: the map. | 1569 | `surface` |