diff options
| author | Gabriel Schneider <[email protected]> | 2026-11-11 19:11:00 -0300 |
|---|---|---|
| committer | Gabriel Schneider <[email protected]> | 2026-11-11 19:35:09 -0300 |
| commit | cc2059e39047cafe1886dc17084855ddd0c52b01 (patch) | |
| tree | 84346e7d956cd16425391e5b07f7ffc7135d34ed /design/motion.md | |
| parent | b54c6776953d3243ab5b8e676e747713827ab320 (diff) | |
| download | computeranim-cc2059e39047cafe1886dc17084855ddd0c52b01.tar.gz computeranim-cc2059e39047cafe1886dc17084855ddd0c52b01.zip | |
design: the disassembly tied to the stack; rsp's moves seen; a column of text as an experiment
From the user. A fact is printed once, in the pane that holds it: under
annotation = .tied a row names the word it touched and a touch line
ties it to its stack row while a step is walked; .whole keeps the full
chain. An instruction that moves rsp or rbp says the amount, and the pin
travels row to row with the rows it gains or releases marked, the stack
following only after it lands. Every strip is ordered cause before
effect and numbered. carry is an optional arrow from memory to a
register. An experiment sets a column of text bubbles beside the panes a
beat is about, each bubble level with what it speaks of, tried on the
call followed down; text may also stand below, above or on a drawing.
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.md | 323 |
1 files changed, 279 insertions, 44 deletions
diff --git a/design/motion.md b/design/motion.md index 2e127b9..461f2a8 100644 --- a/design/motion.md +++ b/design/motion.md @@ -60,6 +60,12 @@ differently now: - `current` is a white wash across the row and the gold plaque; a strike's paper is a softened vermilion, and cools to nothing; `held` is a turned corner, which fades in over the cool's last 6 f. +- The disassembly is `tied` to the stack by default + ([`insn`](README.md#insn)): a row names the word it touches, and a walked + step's [`touch`](README.md#4-ties) draws from the row to the word in + memory's slot, before the word reacts. A read is a cause: a load's word is + reached and read before the register it fills is struck. Charts: "A word + touched", "The stack's own instructions". ## What was measured @@ -144,8 +150,8 @@ A step's length follows from its content: | only moves the line | 12 fire + 12 advance + 24 rest | 0.8 | | writes one register (or one word, or one cell) | 18 + 36 + 12 + 24 | 1.5 | | writes a register and memory | 36 + 48 + 12 + 24 | 2.0 | -| makes a call, three levels shown | 108 + 36 + 12 + 24 | 3.0 | -| returns from one | 126 + 24 + 12 + 24 | 3.1 | +| makes a call, three levels shown | 150 + 36 + 12 + 24 | 3.7 | +| returns from one | 144 + 36 + 12 + 24 | 3.6 | | swaps two cells | 90 + 36 + 12 + 24 | 2.7 | | crosses into the kernel | see the chart | 3.7 to 5.1 | @@ -394,6 +400,52 @@ A read is in the slot of its level. It is gone before the next line fires: in `sort` and `syscalls` read frames stand through the rest and vanish in one frame. +### A word touched + +Under `tied` ([mocks 44, 45](mock/44-tied-store.png)): the row names the word +and the touch carries the eye from the row to it before it reacts. A store, +`next = cur->next`'s last instruction, `mov [rbp - 0x18], rax` (no register +changes, so memory has the first slot): + +| Frames | | +| --- | --- | +| 0 to 12 | fire on the row | +| 18 to 30 | the touch draws from the row's end across the gutter to `next`'s word, head first, `standard`, in write's vermilion | +| 30 to 42, 42 | arm, strike: the word (`405010`), and the row's value with it, an echo | +| 60 to 90 | the idea: `next`'s pin travels under its node, 18 f after the strike | +| 90 to 126 | hold | +| 126 to 138 | advance; the touch draws back into the row (12 f); the cool starts | +| 138 to 162 | rest: 2.7 s with the idea, 1.9 without | + +A load, `mov rcx, [rbp - 8]`: the read is the cause, so it goes first. + +| Frames | | +| --- | --- | +| 0 to 12 | fire | +| 18 to 30 | the touch, in read's colour, to `prev`'s word | +| 30 to 36 | the word framed `read`, and the row's `prev` with it | +| 36 to 48, 48 | arm, strike: rcx (`405050`) | +| 54 to 78 | rcx's link climbs the gutter to its pin under the node of 9 | +| 78 to 114 | hold: the thread, the touch and the link, the three lines | +| 114 to 126 | advance; the touch, the frames and the link draw back | +| 126 to 150 | rest: 2.5 s | + +A store of the value its word already held (a `push rbp` over a frame's +old saved rbp, `cur = head` over a word that held head's value): the touch +lands, the arm's frame comes and goes (12 f) and nothing is struck. + +With `carry = .arrow` ([mock 56](mock/56-carry.png)) the load is one gesture, +the row reaching into memory and the value coming back: fire 0 to 12; the +touch to `prev` 18 to 30, framed 30 to 36; the touch draws back as the carry +leaves the word, up the gutter's right lane to rcx, 36 to 54; rcx armed 54 to +66, struck at 66, the carry drawing back 66 to 84; rcx's link 72 to 96; hold, +advance: 2.8 s. The store draws its carry and no touch: fire; rax framed read +18 to 24; the carry down to `next`'s word 24 to 42; armed 42 to 54, struck at +54; the carry back with the strike; `next`'s pin 72 to 102: 2.6 s. A word +outside the window: the window scrolls (24 f) before the touch draws, and the +touch draws to where the word now is. At a run no touch is drawn: the names +change in place under the run's crossfade. + ### A pointer written | Frames | Memory | The idea (one slot later) | @@ -427,47 +479,83 @@ name that joins or leaves cross-fades over 12 f. ### A call pushed Three levels shown: the registers, the stack, the tree -([mock 12](mock/12-calls-subject.png) is its frame 108). +([mock 12](mock/12-calls-subject.png) is its frame 108 as it was drawn +before the order below; [mock 46](mock/46-tied-call.png) is this order on +`reverse`'s call, instant by instant). The instruction's order: the word the +call writes comes before the pointer that moves onto it. | Frames | | | --- | --- | -| 0 to 12 | fire on the line that calls | -| 6 to 18, 18 | arm, strike: `rdi`, the argument | -| 12 to 24, 24 | arm, strike: `rsp`. Its pin stays on the window's top row: no link | -| 30 to 48 | the stack's rows slide down one slot, `glide`, as rows making room do: the new top row comes in with them | -| 48 to 60, 60 | arm, strike: the return address, in the new top row; the new frame's `call` span (gold, `fib(2)`) and its `backtrace` row fade in with the strike, the old ones going to rule and dim | -| 66 to 72 | the new backtrace row's bracket (`project`): the frame the return address made | -| 72 to 102 | the projection draws from it into the gutter beside the drawing and along the drawing's bottom lane to the place of the new node, 30 f, `standard` | -| 90 to 102 | the edge draws from the caller's node, arriving with the line | -| 102 to 108 | the callee's node fades in gold; the caller's goes from gold to a waiting ring | -| 108 to 144 | hold | -| 144 to 156 | the advance: the mark on the calling line cools to the trail, out 6 f; in 6 f on the callee's first line (the panel scrolls first if it must); the projection draws back out (18 f) | -| 156 to 180 | rest | +| 0 to 12 | fire on the line that calls; its call row says `fib(2) · rsp -8` | +| 6 to 18, 18 | arm, strike: `rdi`, the argument, set by the line's instruction before the call | +| 24 to 36 | the call row fires within the line's step; the touch draws to the free word over rsp | +| 36 to 48, 48 | arm, strike: the return address in it, while rsp has not moved | +| 54 to 78 | rsp's pin climbs onto the word (24 f, `glide`), `-8` on it, the bracket over the word; the new frame's `call` span (gold, `fib(2)`) grows with the pin, the old going to rule and dim; its `backtrace` row fades in | +| 78 | rsp struck as the pin lands, the row's `-8` with it | +| 84 to 90 | the new backtrace row's bracket (`project`): the frame the return address made | +| 90 to 120 | the projection draws from it into the gutter beside the drawing and along the drawing's bottom lane to the place of the new node, 30 f, `standard`; the edge draws from the caller's node, arriving with it | +| 120 to 126 | the callee's node fades in gold; the caller's goes from gold to a waiting ring | +| 126 to 150 | the window follows: the rows glide down a slot, two free words over rsp again | +| 150 to 186 | hold | +| 186 to 198 | the advance: the mark on the calling line cools to the trail, out 6 f; in 6 f on the callee's first line (the panel scrolls first if it must); the projection and the touch draw back | +| 198 to 222 | rest: 3.7 s | +Under `whole` the same, less the touch: the return address is armed at 24. A call is a jump: the mark does not cross the lines between ([sheet](motion/sheets/fib-02.2-mark-crosses-seven-lines.png): seven lines in five frames). ### A return +The `ret` reads before anything moves, and rsp falls last. + | Frames | | | --- | --- | | 0 to 12 | fire on the `return` | -| 6 to 18, 18 | arm, strike: `rax`, the answer | -| 12 to 24, 24 | arm, strike: `rsp` | -| 42 to 48 | the return address framed as read (`ret` reads it); the frame's backtrace row takes its bracket | -| 48 to 78 | the projection, in read's colour, draws from that row to the node, 30 f | -| 78 to 90, 90 | arm, strike: the node's result on its shoulder, rax's digits; the node goes from gold to done, the caller from waiting to gold | -| 96 to 108 | the frame's span and backtrace row fade out, `exit` | -| 108 to 126 | the stack's rows slide up to the new rsp, `glide` | -| 126 to 150 | hold | -| 150 to 162 | the mark jumps back to the caller's line; the projection draws back | -| 162 to 186 | rest | +| 6 to 18, 18 | arm, strike: `rax`, the answer, set by the line's instruction before the `ret` | +| 24 to 36 | the `ret` row fires; the touch (read's colour) draws to the return address | +| 36 to 42 | the return address framed as read; the frame's backtrace row takes its bracket | +| 42 to 72 | the projection, in read's colour, draws from that row to the node, 30 f | +| 72 to 84, 84 | arm, strike: the node's result on its shoulder, rax's digits; the node goes from gold to done, the caller from waiting to gold | +| 90 to 114 | rsp's pin falls past the word, which goes quiet (`free`); the frame's span shrinks with the pin and fades as it ends, its backtrace row with it (`exit`); rsp struck as the pin lands (114) | +| 120 to 144 | the window follows | +| 144 to 180 | hold | +| 180 to 192 | the mark jumps back to the caller's line (6 out, 6 in); the projection and the touch draw back | +| 192 to 216 | rest: 3.6 s | The answer's tie is its digits: rax's and the badge's are the same number, struck one level apart. A line from rax would be a sixth thing in the frame saying what the digits say. +### The stack's own instructions + +The move of rsp or rbp is the event of these steps, and is seen as a move: +the rows hold, the pin travels row by row with its amount on it, the rows it +crosses are gained or released, the frame's span rides it, and the window +follows only after it has landed ([stack](README.md#stack), mocks +[46](mock/46-tied-call.png) and [47](mock/47-tied-prologue.png), each +instant numbered in its order). Under `tied`; in each, nothing downstream is +armed or marked before what is upstream of it has shown. + +| Instruction | What fires · what travels · what lands · what answers, in frames | +| --- | --- | +| `push rbp` | fire 0 to 12 (the row: `rsp -8 · saved rbp`) · the touch to the free word over rsp 18 to 30 · the word armed 30 to 42 and struck at 42 (rbp's own value already there: the arm's frame alone) · rsp's pin climbs onto it 48 to 72, `-8` on it, the bracket over the word, the span stretching, the role `saved rbp` fading in as the pin reaches the row; rsp struck at 72 with the row's `-8` · the window follows 78 to 102 · hold, advance, rest: 2.6 s | +| `mov rbp, rsp` | fire 0 to 12 (`rbp = rsp`) · rbp's pin flies from its row (main's saved rbp, or in from the window's foot) up the lane to rsp's, 18 to 48 (rsp slides aside 36 to 48 for it) · lands at 48, rbp struck · the offsets' base becomes rbp, the tag's note crossfading 48 to 60, no digit changing · hold, advance: 1.9 s | +| `sub rsp, N` | fire 0 to 12 (`rsp -0x18 3 words`) · rsp's pin climbs N/8 rows, 18 to 42 for three (24 f and 6 f a further row, 48 at most), the amount counting as it crosses each row, each row brightening from `free` and its role fading in as the pin reaches it, the bracket and the span under it; where the headroom is not room enough the rows slide down under the pin for the rest, one move · lands, rsp struck with the row's amount · the window follows (if it did not on the way) · hold 24, advance: 1.8 s | +| `add rsp, N` | fire · rsp's pin falls N/8 rows (the same times), each row it leaves released to `free` and its role fading, the span shrinking · lands, rsp struck · the window follows when more than two free words stand over rsp: 1.7 s | +| `pop rbp` | fire 0 to 12 (`rsp +8 · saved rbp`) · the touch (read) to the top word 18 to 30 · framed 30 to 36 · rbp's pin flies to its new row (or out at the window's foot as a stub, `3 rows`) 42 to 72, rbp struck as it lands · rsp's pin falls a row 78 to 102, the word left `free`, the base going to rsp (crossfade); rsp struck at 102 · the window follows · advance: 2.6 s | +| `leave` | fire (`rsp +0x20 · saved rbp`) · the touch (read) to the saved rbp 18 to 30, framed 30 to 36 · rsp's pin falls to it and past it to the return address, 42 to 90 (the locals and the saved rbp released as it passes, the span shrinking to the return address), rsp struck at 90 · rbp's pin flies to the caller's base 96 to 126, rbp struck as it lands · the base to rsp · the window follows · advance: 3.0 s | +| `enter N, 0` | `push rbp`'s order, then `mov rbp, rsp`'s, then `sub rsp`'s, one after another in one step: 4.2 s | +| `call`, `ret` | "A call pushed", "A return", above | + +**Paces.** At a walk as above. At a run the pins still travel and are seen: +8 f and 2 f a row (16 f at most), drawn over the veil with the bracket, the +span and the rows' gain or release, no amount on the pin and no touch; the +window follows in the same 8 f. At a sprint, on the map: rsp is the newest +frame's edge on the stack column, moving with each moment (4 f), the spans +growing and shrinking with it: a deep recursion reads as the column growing +down and coming back. + ### The line changes | | Frames | | @@ -553,17 +641,18 @@ step is a `continue`. Nothing on the kernel's side changes before frame | Frames | | | --- | --- | | 0 to 12 | fire on the call row | -| 12 to 24, 24 | arm, strike: `rsp`. Its pin stays on the window's top row | -| 30 to 48 | the stack's rows slide down one slot, `glide` | -| 48 to 60, 60 | arm, strike: the return address, `main+48` | -| 66 to 78 | the caller's window closes round its call row, first move: the rows it gives up fade out (those after its return row, and from its top as many as the callee needs) | -| 78 to 96 | second move: the rows it keeps glide up to their places, `glide`, where they move at all. Never both at once: a row gliding over a row fading is text on text | -| 84 to 96 | the call row's gold plaque becomes the waiting ring | -| 96 to 114 | the call lane draws down from the ring, head first, `standard`, to the head's place directly under the return row | -| 108 to 120 | the callee's head fades in rising 8 units as the lane reaches it | -| 114 to 138 | its rows fade in top down, 2 f apart, 12 f each | -| 138 to 150 | the advance: the plaque lands on the callee's first row; the source's line goes `waiting` (6 f) where the callee has no source | -| 150 to 174 | rest: 2.9 s | +| 18 to 30 | the touch to the free word over rsp | +| 30 to 42, 42 | arm, strike: the return address, `main+45` | +| 48 to 72 | rsp's pin climbs onto it, `-8` on it, the stub's span arriving; rsp struck as it lands (72) | +| 78 to 102 | the stack's window follows | +| 108 to 120 | the caller's window closes round its call row, first move: the rows it gives up fade out (those after its return row, and from its top as many as the callee needs) | +| 120 to 138 | second move: the rows it keeps glide up to their places, `glide`. Never both at once: a row gliding over a row fading is text on text | +| 126 to 138 | the call row's gold plaque becomes the waiting ring | +| 138 to 156 | the call lane draws down from the ring, head first, `standard`, to the head's place directly under the return row | +| 150 to 162 | the callee's head fades in rising 8 units as the lane reaches it | +| 156 to 180 | its rows fade in top down, 2 f apart, 12 f each | +| 180 to 192 | the advance: the plaque lands on the callee's first row; the source's line goes `waiting` (6 f) where the callee has no source | +| 192 to 216 | rest: 3.6 s | The stub's `jmp`, the next step, reads its GOT slot: fire (0 to 12); the slot framed as read in memory, on the map or in a loupe, and the row's @@ -579,14 +668,15 @@ crossfade to `open`'s (84 to 96, 12 f, never in a frame); advance (96 to | Frames | | | --- | --- | | 0 to 12 | fire on `ret` | -| 18 to 24 | the return address framed as read on the stack | -| 24 to 36, 36 | arm, strike: `rsp` | -| 48 to 72 | `open`'s window closes, its rows fading bottom up, 2 f apart, 12 f each, its head last; the stub's `pass` row with it: the return skips the stub | -| 72 to 84 | the lane draws back up into the ring | -| 84 to 102 | main's window opens in the reverse of its closing, first move: the rows it kept glide back down to their places, `glide` | -| 102 to 114 | second move: the rows it gave up fade in | -| 114 to 126 | the ring becomes a trail bar, the call's annotation takes its result (`= 3`, 6 f), and the plaque lands on the row after the call; the source's line from `waiting` to `current`, its tag crossfading | -| 126 to 150 | rest: 2.5 s | +| 18 to 36 | the touch (read) to the return address, and its frame | +| 42 to 66 | rsp's pin falls past it, the word released to `free`, `open`'s span shrinking away; rsp struck as it lands | +| 72 to 96 | the stack's window follows | +| 96 to 120 | `open`'s window closes, its rows fading bottom up, 2 f apart, 12 f each, its head last; the stub's `pass` row with it: the return skips the stub | +| 120 to 132 | the lane draws back up into the ring | +| 132 to 150 | main's window opens in the reverse of its closing, first move: the rows it kept glide back down to their places, `glide` | +| 150 to 162 | second move: the rows it gave up fade in | +| 162 to 174 | the ring becomes a trail bar, the call's annotation takes its result (`= 3`, 6 f), and the plaque lands on the row after the call; the source's line from `waiting` to `current`, its tag crossfading | +| 174 to 198 | rest: 3.3 s | A descent is a beat the narration names, and each of its steps is walked: at a run the windows open and close in 8 f with no lane drawn, and at a @@ -1422,6 +1512,151 @@ Every caption is up its reading time and at most 450 f, leads its step by 60 f (120 for a chapter's first), and changes only in a rest. The rests are the chapters' ends: 2 s on each last picture. +## A scene in the column: `open` followed down + +The trial of the [column](README.md#column-an-experiment): the syscalls +scene's first part, `open` followed down from main through the PLT and libc +into the kernel and back, built as a variant beside the scene as it is +(`anim/scenes/syscalls.zig`), on the same recording (`hello`, by instruction +from main; the moments below are a fresh recording's, `ztrace record --by insn +--from main`, and move with the build). Vertical position has a meaning here +that it has nowhere else: the story goes down a call at a time to the kernel +and comes back up, and each bubble, level with its row, goes down with it. +Mocks 49 to 53 are five of its beats, 54 the crossing in both forms. + +**As it is** (the present frame, `beside`, the descent in 17 rows, a caption +of two lines under the stage): + +| | Moments | Step | The caption | +| --- | --- | --- | --- | +| P1 | 30 to 34 | walk by line to line 6 | A program cannot open a file itself. / It asks the kernel, and waits. | +| P2 | 34 to 37 | walk to the call | `main` calls `open` by its stub in the PLT, with "note" / in rdi and O_RDONLY in rsi. | +| P3 | 37 to 38 | `descend` | The call goes down: main's call waits, ringed; / the stub's three rows open under it. | +| P4 | 38 to 39 | the stub's jmp | The stub's jmp reads open@got / and goes on to libc's `open`. | +| P5 | 39 to 61 | a run | libc's `open` is a wrapper: a few lines of C, open64.c, / up to the instruction that calls the kernel. | +| P6 | 61 to 64 | walk, three | Its last three set r8 to 0, rdi to AT_FDCWD (-100) / and rax to 257: openat's number. | +| P7 | 64 to 65 | `cross` | `syscall` crosses down. The kernel opens the file / and answers in rax: 3, the descriptor. | +| P8 | 65 to 75 | a run, then `ascend` | `open`'s ret comes straight back to main: the stub / was a jump, not a call. The windows close up. | + +**In the column**: the author's choices, a beat a row, as a scene file is +written from them. *Panes* are in the column's order with their rows (`rest`: +what the column has left above the floor); everything else is on the shelf, +its note given. *Level* is the row a bubble's first line sits beside; +*stem* the row its stem points at in the rest before the step (none: its +level is the tie). Where a cell says *default*, the author wrote nothing +there. + +| | Moments, step | Placement | Panes | Shelf (notes) | The bubble | Level | Stem | +| --- | --- | --- | --- | --- | --- | --- | --- | +| C1 | 30 to 34, walk by line | `below` | the working frame whole (`beside`) | | A program cannot open a file itself. / It asks the kernel, and waits. (the caption, as P1) | | | +| C2 | 34 to 37, three walked | `beside` | source 3 (5 to 7), disassembly 11, registers (14 rows, all) | system calls · its bytes · stack | main puts open's arguments where the convention says: "note" in rdi, 0 (O_RDONLY) in rsi. | default: the `lea` row, the beat's first | default: the same | +| C3 | 37 to 38, `descend` | `beside` | source 3, disassembly 11 becoming the descent, stack `rest` (19 words) | system calls · its bytes · registers (rsp struck) | The call pushes where to come back to, main+45, and goes down to open's stub. | the call row | the call row | +| C4 | 38 to 39, the stub's jmp | `beside` | source 3 (line 6 waiting), the descent (main 8, the stub 3), stack `rest` | system calls · its bytes · registers | The stub in the PLT is one jump: it reads open@got, where the loader wrote libc's open. It pushes nothing. | the stub's `jmp` | the same | +| C5 | 39 to 61, a run | `beside` | source 2, the descent (main 3, the stub 1, open's window following the pc), stack `rest` (open's frame growing: its pins travel over the veil) | system calls · its bytes · registers | libc's open is a wrapper: a few lines of C around the one instruction that calls the kernel. | open's head row | open's head row | +| C6 | 61 to 64, three walked | `beside` | source 2, the descent (main 3, the stub 1, open 6), registers 14 | system calls · its bytes ("note" handed in) · stack (open's frame, 16 words) | Its last three set the kernel's arguments: AT_FDCWD in rdi, and 257, openat's number, in rax. | the first of the three (`xor r8d`) | none | +| C7 | 64 to 65, `cross` | `beside` | source 3 (waiting), the descent with the kernel at its floor (24 rows) | system calls (its row arriving) · its bytes · registers (rax 3 struck, rcx, r11) · stack | syscall crosses down. The kernel opens "note" and answers 3: the file's descriptor, in rax. | the kernel's head | none | +| C8 | 65 to 73 a run, 73 `leave`, 74 `ascend`, 75 the store | `beside` | source 3, the descent closing to main's window (13), stack `rest` (open's frame released as rsp's pin falls) | system calls · its bytes · registers (rax 3) | open's ret comes straight back to main: the stub was a jump, not a call. main keeps the answer in f. | main's call row (the bubble climbs back) | none | +| C9 to C11 | `read`, `close`, `write`, each stepped over | `beside` | its bytes (buf, 3 rows) over the source 3, main's disassembly with the kernel's window under the call row | system calls · registers · stack | the present captions for the three | each call row | each call row | +| C12 | to main's return | `below` | the working frame whole | | the present closing | | | + +**One beat, its frames** (C2 to C3, from the end of C2's last step's rest): + +| Frames | | +| --- | --- | +| 0 to 18 | C2's bubble dims to `dim`, losing its paper | +| 18 to 30 | the registers' rows fade | +| 30 to 54 | the registers' panel closes to its tag as the tag travels to the shelf (24 f, `glide`); its note fades in there: `rsp` | +| 54 to 78 | the stack's tag travels from the shelf to its box as the panel opens under the disassembly (24 f) | +| 78 to 90 | the stack's rows fade in | +| 90 to 114 | C2's bubble glides up out of the way of the next (24 f, `glide`) | +| 114 to 132 | C3's bubble arrives level with the call row, rising 8 (18 f) | +| 120 to 132 | its stem draws to the call row | +| 132 to 192 | the lead: the bubble read, the frame still | +| 192 | the step fires (`descend`, its touch to the free word over rsp, as "A call pushed"), and the stem draws back over its first 12 f | + +So a beat that changes its panes costs about 96 f, 1.6 s, over the caption's +change (out 12, gap 6, in 18, then the same 60 f lead), and a beat that keeps +them nothing. Over C2 to C8 the panes change five times: about 8 s on a part +of some 45 s. + +**What the scene's code says for a beat.** The author's choices are the +beat's arguments, each optional; what it leaves out is defaulted as the +catalogue says, never against what it wrote: + +```zig +// C3: the call goes down. The stack under the descent, the rest on the shelf. +col.beat(s, .{ + .panes = &.{ .{ .source, 3 }, .{ .disasm, 11 }, .{ .stack, .rest } }, + .say = "The call pushes where to come back to, `main+45`,\nand goes down to open's stub.", + .at = .beside, // .below .above .on; default .beside in a column scene + .level = .{ .row = call }, // default: the row of the beat's first step + .stem = .{ .row = call }, // default: what it is level with; .none +}); +canim.descent.step(cur, s, .moment); // the step itself, as in the scene now +``` + +**What it costs and gains, beat by beat** (the working frame against the +column, at each beat's hold): + +| Beat | The working frame shows | The column shows | Leaves on the shelf | +| --- | --- | --- | --- | +| C2 | source 8, disassembly 17, registers 14, stack 11, the log and its bytes | source 3, disassembly 11, registers 14 | the stack (nothing changes in it), the log, its bytes | +| C3 | the same; the descent closing main's window to 3 | source 3, the descent, a stack of 19 words with the return address on top | the registers (rsp struck on its tag) | +| C4 | the descent 17 (main 3, stub 3) | the descent 12 (main 8, stub 3) and the stack (the return address held: the stub pushes nothing) | the registers | +| C6 | the descent 17, registers 14 | the descent 12 (open 6), registers 14 (rip above 888) | the stack | +| C7 | the descent 17 (open 8), registers 14, stack 11 | the descent 24 (open 13, the kernel 2) | the registers (rax 3 struck on the tag), the stack, the log (its row) | +| C8 | the windows closing, stack 11 | main 13, a stack of 18 | the registers | + +Nothing the narration depends on is only on the shelf: rax's 3 is in the +kernel's `returns 3`, on the registers' tag, and in the bubble; rsp's move is +the stack's pin when the stack stands, and the registers' tag when it does +not. The context is whole at C1 and C12 (`below`), on the shelf throughout, +and on the map. + +**How the render is to be judged**, both variants played to the same viewer +(the user, on the device the videos are watched on), at 1080p and at 480p: + +- At each beat's hold, with the sound off: can one say what the step did and + where, from the frame alone? Count the beats where the column's answer is + quicker, and where something wanted was folded. +- Eye travel: the distance from the bubble's first line to the step's mark + (the current row, the struck value); within two rows for most of each + beat in the column, against the caption's 300 to 800 in the working frame. +- The account: after the crossing, can the viewer find what the call row's + bubble said without rewinding? +- The motion instruments (CROWD, POP, METRONOME, CAPTION, AIR): no POP from + a fold or an unfold, no CROWD from the beat changes. +- Time: the scene no more than a sixth longer. +- Taste, said plainly: whether the frame with half its panes folded feels + like canim (the whole context, pwndbg's density) or like a slide deck. + +**What I think.** A style for some scenes and some beats, not the way every +scene is made: it wins where the story is a column of rows that goes down and +comes back (a call followed down, a recursion, the stack growing, a loop told +turn by turn beside its rows), and loses where every step acts on the program +and the state at once (sort's swaps with the array, the heap scene's two rows +of nodes and their bytes): there the working frame is the subject and its text +belongs `below` or `above`. So the placements are the instrument: a scene +mixes `below` and `beside` beat by beat, `on` for a drawing with room, and the +working frame stays the language's default and a column scene's opening and +close. + +**If it wins**, what changes in the two storyboards waiting for it. *The ASan +pair*: its facing beats need both runs side by side and stay `below` (or +`above`, the seam undisturbed); from i = 16, when they part, plain goes on +alone: its frame's bytes (`hexdump` `eight`) stand in the panes' column the +height of the stage, and each bubble sits level with the field the turn's +letter lands in, `buf`, the saved rbp, the return address, so the narration +climbs the frame as the overflow does; ASan's report is unfolded as the +subject of its own beat, a bubble level with each line it explains (`WRITE of +size 1`, `[32, 48) 'buf'`). *The introduction*: `segments` is a tall subject, +`beside`, a bubble level with each band as it is enlarged, the stack's at the +top and the program's at the foot, so the chapters go down the address space; +`regroup` at x2 is a drawing with room, its bubble `on` it beside the walked +word; `aligned` spans both columns and keeps its text `above`; the stack panel +built over the words is `beside`; and its one walked load is the beat for +`carry = .value`. + ## Stills Seen while looking at motion; against `README.md`. |
