diff options
Diffstat (limited to 'design/motion.md')
| -rw-r--r-- | design/motion.md | 194 |
1 files changed, 129 insertions, 65 deletions
diff --git a/design/motion.md b/design/motion.md index 9a01afb..07ffabc 100644 --- a/design/motion.md +++ b/design/motion.md @@ -446,6 +446,15 @@ 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. +With `carry = .after_touch` a store draws both, the row naming the word and +then the value going there: the touch to the word first (18 to 30), then the +source register framed read and the carry down from its row to the word, the +word armed and struck as it lands; what follows (rsp's pin climbing onto a +pushed word) only after. The introduction's `push rbp` (II4) is drawn so, +and there a store of the value the word held is struck as any write, its +mark gone by the step's end and no corner held: the store is the event the +viewer is being shown, and the carry would otherwise land on nothing. + ### A pointer written | Frames | Memory | The idea (one slot later) | @@ -829,41 +838,46 @@ 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. +`regroup`, walked, on the return address's eight bytes (`72 12 40 00 00 00 +00 00` at `7fffffffebc8`, the dump's first word: at a function's first +instruction rsp points at the way back; [mock 37](mock/37-regroup.png) +draws it on the older list recording's `b0 18 00 01 00 00 00 00`), from the +beat's step. The camera is at x2 on the dump the whole time, with the room +over it that the bytes fly in; 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` | +| 48 to 66 | the veil over every row but the walked one; the dump's header fades, leaving its row to the offsets (it comes back as the veil lifts) | +| 66 to 92 | its offsets fade in over its bytes, in the header's row, `+0` to `+7`, left to right, 2 f apart, 12 f each (`column`) | +| 84 to 96 | `low byte` left of `+0`, `high byte` right of `+7`, in the same row: outside the run, never under another row's bytes | | 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) | +| 108 to 258 | the bytes fly, the low byte first, one at a time: byte k lifts at 108 + 18k, 24 f, so that the next lifts as it comes down and none crosses another in the air. Each goes straight up off its place to 40 over its row (clear of the offsets standing there), over, and straight down onto its pair's place in the word's field, the pairs 30 apart and ranged right (`glide` across, the rise and the fall each a quarter of the flight). In the air it is bright and bold on its own ground of page, its offset riding 22 over it; the offset lands over it, so the field reads `+7` to `+0`. `low byte` goes as its byte lifts and comes back right of `+0` as it lands (the word's last pair); `high byte` goes as `+6`'s byte lifts (it stands where `+6` lands) and comes back left of `+7` as its own lands. 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, and no row of memory is crossed | +| 264 to 276 | the gaps close: the pairs glide right to sixteen digits, `0000000000401272` (12 f, `glide`); the offsets and labels fade with them (closed, their pairs would touch) | +| 276 to 288 | a faint bracket under the zeros in front, `zeros in front` under it on a ground of page only as wide as its label, fades in | +| 288 to 300 | still | +| 300 to 312 | the zeros and their bracket fade: `401272`, ranged right where it was | +| 312 to 342 | still | +| 342 to 360 | the veil lifts | +| 360 to 458 | the other fifteen at a run: rows top down, 6 f apart, each word fading in (8 f) as its bytes dim (8 f), each as the stack will write it (an address bare, a number as [`value`](README.md#value) writes it: `0x100000000`) | 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. +were. Eight flights at once would cross; one at a time, low byte first, the +order of the landing is the order of the reading, and over the row there is +room for one. ### 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: +The whole first, deliberately: the bar grows from the top down (72 f, +`standard`), its ends' addresses and its size (18 f), then the 2-unit lines +of every mapping at its ends (12 f each, over 72 f). Then `enlarge`, a box a +cluster, from its start e: | Frames | | | --- | --- | @@ -874,8 +888,9 @@ from its start e: | 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 +lands), the program's in a beat of its own: 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. @@ -886,9 +901,17 @@ names: | --- | --- | | 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) | +| l+42 to l+54 | the head lands; the stack's band framed bright (6 f in, 12 out); with it, never before, the dump's addresses take the stack's ink and its header goes (12 f): the place is said, so the header's words give way to its ink | | 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 | +A visit to it (I8) at x2 frames the stack's box and the dump's top rows +together, so that the link standing between them is whole and no label is +cut at the frame's edge (only the dump's rows run on out of it). At that +scale the 128 bytes are still far thinner than a unit, so their place is +marked: a 2-unit tick across the box in the stack's ink at the dump's +address, `128 bytes` over it left of the link's head (12 f in once the +camera has landed, held 60 f, 12 f out before it goes back). + ### The camera In, to x2: @@ -1485,11 +1508,18 @@ 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 -123 s. Each view grows out of the rawer thing under it, in the order the +The frame built from its bytes up, on a recording of its own (`intro`: +`anim/tools/list.c`, three nodes pushed onto a global list and the list +reversed, built as the compiler alone makes it, clang `-O0 -g +-mno-red-zone`, with no instrumentation: nothing the viewer is walked +through is a tracer's, `reverse` gets a real prologue, `push rbp; mov rbp, +rsp; sub rsp, 0x18`, and its locals are named by the debug info). Chapters +I and II stand at reverse's first instruction, its `push rbp`, where rsp +holds the way back to main (`401272 main+50`); III at the load on line 21, +`mov rax, [rax + 8]`. 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 157 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 @@ -1501,7 +1531,8 @@ 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 and for the stack and registers, whose text stands in the program -column while it is empty), so the frame's empty parts are +column while it is empty; once more at x2 for the visit of I8, and none +in III, where the band is whole at x1), 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. @@ -1514,55 +1545,88 @@ bubbles level with each end as it is enlarged, so the chapter goes down the address space with them, while the bytes wait on the shelf; the working frame again to tie the bytes to their place; in chapter II the text `beside` on the left, in the program column, which holds nothing else until III but -the three rows of main the return address aims at (II2, the scene's one -`aim`), level with the stack's rows it speaks of; in III `above` the aligned source and code, which -span both columns and read down, then `below` as the working frame assembles, -and `on` the map. Every text lands in a rest, leads its step by 60 f (120 for -a chapter's first), is up its reading time and at most 720 f, and is covered -by its lead, its steps and a hold of at most 84 f. +main's three rows round its call (the return address aims at one: II3, the +scene's one `aim`) and reverse's first seven under them (the disassembly II +walks), level with the stack's rows it speaks of; in III `above` the aligned +source and code, which span both columns and read down (wrapped at 80 +characters: two lines in the band of 120), then `below` as the working frame +assembles, and still `below` as the map surfaces under it. Every text lands +in a rest, leads its step by 60 f (120 for a form's first in III: III1 +above, III3 below; I1's is 60 too, so that its rows come while it is read +rather than its "here" standing over an empty stage), is up its reading time +and at most 720 f, and is covered by its lead, its steps and a hold of at +most 84 f. A chapter's last picture holds until its last text is read and +2 s at least ([caption](README.md#clock-and-caption)); II and III hold the +2 s after the reading, so that the map is never cut while it is read about. + +**Names after the things.** Nothing is named before it is shown, in a text +or a label: the first text says bytes, not the stack; the dump's header is +`128 bytes at 7fffffffebc8` and its tag on the shelf `the 128 bytes`; the +stack is named at I7, where its box is on screen, and rsp at II2, where its +row arrives. A convention is said where it first shows: the chain's arrows +at I10, the stack panel's direction at II1 (the bar draws high addresses on +top, the panel low on top, and the push goes up a row), the width squares +with `columns`, the minimaps at III4. + +**Notation.** From I's regroup on, a word that is no address is written as +the stack will write it (the [`value`](README.md#value) atom: `0`, `1`, +`0x100000000`), so a number reads the same in I and in II. The stack's +offsets and a pin's amount take `0x` from 0x10 up (`-8`, `+0x10`, `rsp +-0x18`): beside a symbol's decimal offset (`main+50`), `-10` after `-8` +would read as ten. + +The frames are the build's: a text *lands* when it has arrived, its step +*fires* its lead after, and it *leaves* when it starts to go (a bubble +that stays as the account *dims* instead). -**I. Memory** (66.2 s) +**I. Memory** (70.0 s) | | Form · text | Panes (rows) · shelf | Level | The step, and what plays | Text (characters) | Lands | Fires | Leaves | | --- | --- | --- | --- | --- | --- | --- | --- | --- | -| I1 | working frame · below; the camera at x2 on the state column | the dump of 128 bytes, sixteen a row, eight rows, no ink, the addresses faint (mock 29) | | the bytes fade in a row at a time (18 f, 12 f apart) | A running program is bytes in memory: here, 128 of them at the top of the stack. (80) | 78 | 198 | 456 | -| I2 | the same | the dump | | `regroup`: sixteen a row to eight, the return address walked, the other fifteen at a run (mock 37, [chart](#a-word-read)) | Eight bytes make a word, stored low byte first: the lowest byte is its last two digits. (87) | 474 | 534 | 956 | -| I3 | the same | the dump, sixteen words | | three words that hold addresses framed as read, one at a time, 30 f apart | Some words are addresses: they name a place in memory. (54) | 974 | 1034 | 1258 | -| | | | | 1276 to 1384, into the column: the camera out to x1 (72 f); the dump folds to its tag (`the stack's 128 bytes`) on the shelf; the program column opens to the column's height for `segments` | | | | | -| I4 | column · beside | `segments` (treatment A, mock 34), the panes' column from 84 to 888: a slim bar the column's height, true scale | the bar's middle | the whole builds, deliberately: the bar grows from the top down (48 f), its two ends' addresses and its size, then the lines of every mapping at its ends (48 f) | Its address space, 128 TiB, to scale: mapped only at each end. (62) | 1384 | 1444 | 1698 | -| I5 | column · beside | `segments` | the stack's box, at the top | `enlarge`: the stack's box rides out (78 f) and its names come, each band with its start and end addresses and its size; then the libraries' box the same | Enlarged, the top end: the stack, then the libraries, each band with its addresses and size. (92) | 1716 | 1776 | 2137 | -| I6 | column · beside | `segments` | the program's box, at the foot (the bubble's way down) | `enlarge`: the program's box, by segment (code, read-only data, data, the heap), its names | At the foot, the program: its code, its data, its heap. (55) | 2155 | 2215 | 2443 | -| | | | | 2461 to 2557, back to the working frame: the bubbles leave; `segments` keeps the program column, its height eased to the stage's (24 f, the drawing scaling as one); the dump unfolds from the shelf in the state column, at x1 | | | | | -| I7 | working frame · below | `segments` in the program column; the dump in the state column | | the dump's place: the `tie` bracket on its rows (6 f), the `link` over the top onto the stack's box (36 f), the band framed bright as it lands (mock 30) | These 128 bytes are here, at the very top of the stack. (55) | 2557 | 2617 | 2845 | -| I8 | working frame · below | the same | | a camera `visit` at x4 to the top of the stack's box, where the link lands, and back (72 f each way) | Were the bar the Eiffel Tower, they would be an atom thick, at its top. (71) | 2863 | 2923 | 3208 | -| I9 | working frame · below | the same | | `ink` on the return address, walked: its digits, its band and its row framed (an echo); the rest at a run, 2 f apart; the link quiets | A word takes the ink of where it points: 10018b0 is list's code. (64) | 3226 | 3286 | 3547 | -| I10 | working frame · below | the same | | the words glide to their field's left (24 f) to give their chains room; three chains grow (`extend`), walked | Follow an address and you reach another word: a chain. (54) | 3565 | 3625 | 3849 | +| I1 | working frame · below; the camera at x2 on the state column | the dump of 128 bytes, sixteen a row, eight rows, no ink, the addresses faint, its header over them, `128 bytes at 7fffffffebc8` (mock 29) | | the rows fade in a row at a time (18 f each, 18 f apart: they come while the text is read) | A running program is bytes in memory: here are 128 of them. (59) | 78 | 138 | 380 | +| I2 | the same | the dump | | `regroup`: sixteen a row to eight, the return address (the dump's first word) walked, the other fifteen at a run (mock 37, [chart](#a-word-read)) | Eight bytes make a word, stored low byte first: the lowest byte is its last two digits. (87) | 416 | 476 | 965 | +| I3 | the same | the dump, sixteen words | | three words that hold addresses framed as read, one at a time, 30 f apart | Some words are addresses: they name a place in memory. (54) | 1000 | 1060 | 1285 | +| | | | | 1285 to 1476, into the column: the text leaves (12 f); the camera out to x1 (72 f, then 36 still); the dump folds to its tag on the shelf, `the 128 bytes` (its rows glide up into its header, the header becomes the tag, the tag slides to the shelf, 24 f each way: README, [column](README.md#column), "Mixing them"); the program column opens to the column's height for `segments` | | | | | +| I4 | column · beside | `segments` (treatment A, mock 34), the panes' column from 84 to 888: a slim bar the column's height, true scale | the bar's middle | the whole builds, deliberately ([chart](#the-address-space-enlarged)) | Its address space, 128 TiB, to scale: mapped only at each end. (62) | 1476 | 1536 | dims 1790 | +| I5 | column · beside | `segments` | the stack's box, at the top | `enlarge`: the stack's box rides out (78 f) and its names come, each band with its start and end addresses and its size; the libraries' box rides as the stack's lands | Enlarged, the top end: the stack, then the libraries, each file with its addresses and size. (92) | 1808 | 1868 | dims 2229 | +| I6 | column · beside | `segments` | the program's box, at the foot (the bubble's way down) | `enlarge`: the program's box, by segment (code, read-only data, data, the heap), its names | At the foot, the program: its code, its data, its heap. (55) | 2247 | 2307 | 2542, the three together | +| | | | | 2542 to 2661, back to the working frame: the texts leave together (12 f); `segments` keeps the program column, its height eased to the stage's (24 f, the drawing scaling as one); the dump unfolds from the shelf in the state column, at x1, the fold backwards (2578 to 2626) | | | | | +| I7 | working frame · below | `segments` in the program column; the dump in the state column | | the dump's place ([chart](#the-address-space-enlarged), mock 30): the `tie` bracket on its rows, the `link` over the top onto the stack's box, the band framed bright as it lands, and with it the dump's addresses taking the stack's ink | These 128 bytes are here, at the very top of the stack. (55) | 2661 | 2721 | 2949 | +| I8 | working frame · below | the same | | a camera `visit` at x2 to the dump's place, the stack's box and the dump's top rows framed together ([chart](#the-address-space-enlarged)): the move (72 f), the place marked `128 bytes` on the box, back (72 f) | Were the bar the Eiffel Tower, they would be an atom thick, at its top. (71) | 2985 | 3045 | 3370 | +| I9 | working frame · below | the same | | `ink` on the return address, walked: its digits, its bytes, its band and the band's row framed (an echo); the rest at a run, 2 f apart; the link and its bracket quiet to standing (24 f) | A word takes the ink of where it points: 401272 is list's code. (63) | 3405 | 3465 | 3729 | +| I10 | working frame · below | the same | | the words glide to their field's left (24 f) to give their chains room; three chains grow (`extend`), 36 f apart | Follow an address and you reach another word: a chain. → points to a word, ← holds a value. (91) | 3765 | 3825 | | -The chapter's last picture, 2 s, to 3969. +The chapter's last picture: 2 s after the last step, and on until its text +is read, to 4199. -**II. The stack** (26.5 s), opening on I's last picture +**II. The stack** (42.5 s), opening on I's last picture | | Form · text | Panes (rows) · shelf | Level | The step, and what plays | Text (characters) | Lands | Fires | Leaves | | --- | --- | --- | --- | --- | --- | --- | --- | --- | -| II1 | working frame, text beside on the left (the program column, empty until III) | the address space and the dump's link fade (18 f); the words become the stack panel in the state column, 16 slots, the headroom over rsp | rsp's row | rsp's row arrives over the stack, its pin landing on the top word; `reverse`'s `push rbp` replayed from the recording by instruction: the touch, the word, rsp's pin climbing onto it (README, stack) | rsp holds the address of the top of the stack. A push moves it down a word. (75) | 78 | 198 | 438 | -| II2 | the same; `aim = .step` for this beat | the stack; under the bubble, in the program column, three rows of main's code arrive (a descent's head row, `main`, then `call reverse`, `10018b0`, the next): the first code on screen | the return address's row | the word `10018b0 main+80` framed (516 to 522); the three rows fade in (528 to 546); the aim draws from the word across the gutter to the row `10018b0`, the one after the call (552 to 570), its address framed; the offsets arrive (`column`, 582 to 630). The rows stay, faint, and III's disassembly opens round them | A call pushes the address to come back to: here, main+80. (57) | 456 | 516 | 751 | -| II3 | the same | the stack | the frame's span | roles (`column`), the spans, rbp's pin; the stack's tag (`frame up`) | A function's words are its frame: the saved rbp, its locals, the way back. (74) | 769 | 829 | 1126 | -| II4 | the same | the registers built over the stack, a row at a time, top down, then their tag, its legend the inks of I (mock 31) | rax's row | the build | The registers are the other place values live: seventeen of them. (65) | 1144 | 1204 | 1468 | +| | | | | 0 to 96: I's last picture (30 f); the address space and the dump's link fade (18 f); the words glide into the stack panel's rows where it stands in the working frame (36 f, the bytes going first and the addresses travelling to the slots' column) and become it (12 f): sixteen words and four `free` over rsp. The window is held there through the chapter: the push and `sub rsp` fill the free words and only pins move, no row | | | | | +| II1 | working frame, text beside on the left (the program column, empty until II3) | the stack; its offsets, roles, spans and tag, and the registers, under the page until their beats | the stack's first row | the convention said where the panel first stands: the offsets come down the rows (`column`, 4 f apart), counting from rsp | Here lower addresses are drawn higher: down a word is up a row. (63) | 114 | 174 | 431 | +| II2 | the same | rbp's and rsp's rows, the registers' first two, arrive over the stack | rsp's row | the two rows (12 f); rsp's pin lands on the top word (12 f); rsp's link from its row down to the word, a link on the beat (README, [`link`](README.md#6-verbs)): rsp framed, the link (36 f), held 1 s, drawn back (18 f) | rsp holds the address of the top of the stack. (46) | 466 | 526 | 730 | +| II3 | the same; the scene's one `aim`, `drawn` | main's three rows in the program column, level with the lower stack (a descent's head, `main`; `40126d call 4011a0 reverse`; `401272 call 401200 clear`; `401277 xor eax, eax`): the first code on screen | the return address's row | the call first, as it happened, before the push: the word `401272 main+50` framed as read (6 f); main's rows (12 f each, 2 f apart); the `aim` from the word down the gutter's left lane to `401272`, the row after the call, head first at full ink (18 f), the address framed as the head lands (6 f) | A call pushes the address to come back to: here, main+50. (57) | 765 | 825 | 1068 | +| II4 | the same | reverse's first seven rows, the disassembly, under main's (its rules, tag and strip under the page until II5); rbp's pin | the free word over rsp | the aim falls to standing at 60% (18 f), the word's frame goes and main's rows go faint (18 f); reverse's rows (12 f) and rbp's pin (12 f); `push rbp` walked, its row fired by the pc's mark: the touch to the word, then rbp's value carried there from rbp's row (`carry` `after_touch`) and struck, though the word held that value; rsp's pin climbs onto it, `rsp -8`, and rsp is struck | A push moves rsp down a word and stores there: push rbp keeps the caller's rbp. (79) | 1104 | 1164 | 1500 | +| II5 | the same | the stack, its roles and spans; the disassembly's and the stack's rules and tags | the frame's span | the aim leaves (18 f); `mov rbp, rsp` walked (rbp's pin flies to rsp's row; the offsets now count from rbp), `sub rsp, 0x18` walked (rsp's pin climbs three rows, `rsp -0x18`, `3 words`); the roles (`column`: `cur`, `prev`, `saved rbp`, `the way back`, and the callers' below), the spans (`column`); `frame up` on the disassembly and the stack, the rules (12 f) then the tags and strips (12 f) | rbp marks the frame's base. A function's words are its frame: the saved rbp, its locals, the way back. (102) | 1536 | 1596 | dims 2088 | +| II6 | the same | the registers' other rows built over the stack, a row at a time, top down, then their rules and tag, its legend the inks of I (mock 31) | the registers' third row | the build, 12 f a row, 12 f apart | The registers are the other place values live: seventeen of them. (65) | 2106 | 2166 | | -The chapter's last picture, 2 s, to 1588. +The chapter's last picture, 2 s after its text is read, to 2552. -**III. Code and meaning** (30.3 s) +**III. Code and meaning** (44.8 s), opening on II's last picture | | Form · text | Panes (rows) · shelf | Level | The step, and what plays | Text (characters) | Lands | Fires | Leaves | | --- | --- | --- | --- | --- | --- | --- | --- | --- | -| III1 | working frame · above | the code's bytes as a dump row in code's ink, across the stage | | the row arrives (12 f), its sixteen bytes take code's ink 2 f apart, one instruction's four bytes framed | Code is bytes too: 48 8b 7f 08 is one instruction. (50) | 78 | 198 | 348 | -| III2 | `aligned` · above | `aligned`, `interleaved`, across both columns (mock 32) | | `decode`, the instruction walked and its neighbours at a run; the source's lines arrive level with their runs | Decoded: mov rdi, [rdi + 8], from line 21. Each line sits level with its code. (78) | 366 | 426 | 737 | -| | | | | 755 to 803: the text above leaves; `stack`: the aligned columns become the program column | | | | | -| III3 | working frame · below | the program column, the state column as II left it; the band | | the heap's dump arrives in the band's right half, then the nodes drawn from it (`establish`) | rdi pointed at a list node on the heap: its bytes, and drawn, the node. (71) | 803 | 863 | 1148 | -| III4 | working frame · below | the working frame of mock 9 | | the camera out to x1; each pane's minimap draws itself last, top down | This is the whole frame. Every view in it is these same bytes. (62) | 1166 | 1226 | 1480 | -| III5 | the map · on, in the key's corner | the map | | `surface` | And all of it at once: the map. (31) | 1498 | 1558 | 1699 | +| | | | | 0 to 96: II's last picture (30 f); its texts leave (12 f) and its code fades (18 f); its state column is veiled at 50% (18 f) and stays, veiled, until the decoded rows come to span it | | | | | +| III1 | working frame · above | the code's bytes as a dump row in code's ink, in the program column | | the row arrives (12 f), its sixteen bytes take code's ink 2 f apart, one instruction's four bytes framed | Code is bytes too: 48 8b 40 08 is one instruction. (50) | 96 | 216 | 374 | +| III2 | `aligned` · above | `aligned`, `interleaved`, across both columns (mock 32) | | `decode`, the instruction walked (60 f) as II's state column goes under it (12 f); its neighbours at half a run's pace (rows 4 f apart), each line heading its run, while the text is read; the panel's rules and tag (24 f) | Decoded: mov rax, [rax + 8], from line 21. Each line heads the instructions it compiled to. (91) | 409 | 469 | 834 | +| III2b | `aligned` · above | `aligned`, `columns` (mock 36) | | `align` to `columns` at two thirds of its pace (120 f), while the text is read | Two columns: each line by its first instruction. A square after ]: a byte it touches. (85) | 870 | 930 | 1274 | +| | | | | 1274 to 1435, into the working frame: the texts above leave (12 f); `stack`: the lines glide to the source panel's rows, the instructions to the disassembly's (60 f), those panels coming in under them as the aligned panel goes (12 f); `establish`: the clock, the registers, the stack and the ties, at III's moment | | | | | +| III3 | working frame · below | the program column, the state column at the load; the band | | the heap's dump in the band's right half (18 f), then the nodes drawn from it, rising (`establish`); rax framed as read and its link up to the node it points at, a link on the beat | Later, at line 21, rax points at a list node on the heap: its bytes, and drawn, the node. (89) | 1435 | 1555 | 1853 | +| III4 | working frame · below | the working frame of mock 9 | | each pane's minimap draws itself, last, top down (24 f each, 72 f apart, while the text is read). No camera: at x1.5 the nodes and their bytes would not both be in frame | This is the whole frame. Every view in it is these same bytes; each strip, the whole of its pane. (97) | 1888 | 1948 | 2328 | +| III5 | the map · below: the text lands before the move and stays under the map as under the frame | the map | | `surface` | And all of it at once: the map. (31) | 2364 | 2424 | | -The last picture, 2 s, to 1819. Together 123 s. +The last picture, the map, 2 s after its text is read, to 2687. Together 157 s. ## A scene in the column: `open` followed down |
