summaryrefslogtreecommitdiff
path: root/design/motion.md
diff options
context:
space:
mode:
Diffstat (limited to 'design/motion.md')
-rw-r--r--design/motion.md54
1 files changed, 54 insertions, 0 deletions
diff --git a/design/motion.md b/design/motion.md
index da903ab..bc58c6f 100644
--- a/design/motion.md
+++ b/design/motion.md
@@ -1238,6 +1238,60 @@ fault: the signal, rip and rsp at it, the exit status. And for the pair:
the two recordings' stops matched by source line and by the loop's turn (i
from its slot), so a step can be one line or one turn in both.
+## A scene: the introduction
+
+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
+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
+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)
+
+| 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 |
+
+**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 |
+| 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) |
+
+**III. Code and meaning** (32.1 s)
+
+| 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) |
+| 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` |
+
+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.
+
## Stills
Seen while looking at motion; against `README.md`.