summaryrefslogtreecommitdiff
path: root/design/README.md
diff options
context:
space:
mode:
authorGabriel Schneider <[email protected]>2026-11-11 22:10:47 -0300
committerGabriel Schneider <[email protected]>2026-11-11 23:46:02 -0300
commit9c0696447dbc5cf37e56aee562c7ebba4f4d4e6b (patch)
tree720b15eeee82900a50dc2f5712c8ed364638aa5d /design/README.md
parent479d4914ecd8c7bfea68f9357ace1a4a6d0006ab (diff)
downloadcomputeranim-9c0696447dbc5cf37e56aee562c7ebba4f4d4e6b.tar.gz
computeranim-9c0696447dbc5cf37e56aee562c7ebba4f4d4e6b.zip
design: aim, a word holding a code address joined to its row; relations as one data model
From the user. aim joins a value on screen that is a code address (a return address, a function pointer, a GOT slot) to its row in the disassembly, off unless the scene's author turns it on; when the word is overwritten the head glides to the new row, or frays when it no longer points at code. Every relation is now one model, as data: tables per frame of places, values that may be addresses and the step's events; the kinds as one table of their joins, knobs, priority, ink, route and timing; a resolver of six passes over those tables, one budget, and no kind drawn because the budget has room. Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
Diffstat (limited to 'design/README.md')
-rw-r--r--design/README.md190
1 files changed, 152 insertions, 38 deletions
diff --git a/design/README.md b/design/README.md
index 253be7a..0899e50 100644
--- a/design/README.md
+++ b/design/README.md
@@ -86,6 +86,7 @@ this table.
| | [`echo`](#4-ties) | the same mark in two panels at once | for a step |
| | [`touch`](#4-ties) | this instruction reads or writes that word | for a walked step, while the row is current; `tied` only |
| | [`carry`](#4-ties) | this value went from that word to this register, or back | a scene's knob, off by default; for a walked step |
+| | [`aim`](#4-ties) | this word holds the address of that instruction | the author's knob, off by default; for a step, or standing through a beat |
| 5 frame | [`stage`](#5-the-frame) | the working frame: the band and the two columns | split `none`, `beside`, `subject`, `blocks` |
| | [`segments`](#segments) | the process's address space to scale, each end enlarged, its bands' addresses at their edges | treatments A (default), B, C; the ink's source: a band framed when a word is inked; a dump's place |
| | [`aligned`](#aligned) | the source and its instructions in one panel, each line level with its code | `interleaved`, `columns`; a split a scene chooses |
@@ -98,7 +99,7 @@ this table.
| | [`caption`](#clock-and-caption) | the narrator | |
| | [`veil`](#clock-and-caption) | page over what a beat does not touch, or a pace cannot show | |
| | [`card`](#clock-and-caption) | a title, the legend: no program running | |
-| 6 verb | [`fire` `arm` `strike` `cool` `read` `extend` `link` `project` `touch` `carry` `travel` `follow` `advance`](#6-verbs) | what one block does | |
+| 6 verb | [`fire` `arm` `strike` `cool` `read` `extend` `link` `project` `touch` `carry` `aim` `travel` `follow` `advance`](#6-verbs) | what one block does | |
| | [`open` `close`](#6-verbs) | what a loupe does | |
| | [`descend` `cross` `ascend`](#6-verbs) | what a descent does: a call followed down, a system call, a return | |
| | [`regroup` `ink` `enlarge` `column` `frame up` `decode` `align`](#6-verbs) | what building a view does (the introduction) | |
@@ -1327,18 +1328,117 @@ opens and closes by its verbs ([`open`, `close`](#6-verbs)). Mocks 19 and 21.
## 4. Ties
-The panes are one machine at different levels. A tie says which thing in
-one pane a thing in another is.
+The panes are one machine at different levels. A tie says which thing in one
+pane a thing in another is. Every tie is a **relation**, and the relations
+are one data problem, solved the same way for every kind: per frame, tables
+of places and of values; the kinds as one table of properties; relations as
+joins between them; and a resolver that is a pipeline of passes, each a loop
+over a table. The code mirrors this section; each kind keeps its specifics in
+its own section (its block, its verb).
-| Tie | Says | Between | When | Form |
-| --- | --- | --- | --- | --- |
-| `thread` | this line is these instructions, and the machine is here | the source's current line; every run of its instructions in the disassembly | standing; moves with the current mark | gold, 3 units: a `tie` bracket on the line, one on each run, a line in the left margin (x 54) between them. On the map, where source and disassembly are side by side, across their gutter (x 1008) |
-| `link` | this register now points at that; these bytes are there | the `reg` just struck; the row or node whose address it holds. In the introduction, a dump's rows and their place in [`segments`](#segments) | for the step that set it; a dump's place stands while both are on screen | 3 units, in the ink of the region pointed into, head on the target; ends in the target's `pin` and leaves it behind. From a dump, from a `tie` bracket on its rows |
-| `projection` | these bytes are that part of the drawing | a run a step read or wrote, in the dump; or the return address of a frame made or ended, on the stack; the part of the drawing made of them (a node's address, a cell, a call's node) | for that step | 2 units in the mark's colour (read, write): a `tie` bracket on the row, a line, a bracket at the part (over a node's address; under a call's node); and the mark itself on the run and on the part |
-| `echo` | these are one event | the same mark at the same instant in two panels: the annotation's address (or, `tied`, its name) and the dump's run or the stack's word | for that step | no line |
-| `touch` | this instruction reads or writes that word | the current `insn`; the stack word it reads or writes (a push's, a call's and a return's included), in the stack beside it. `tied` only | a walked step, from just after the fire until the advance | 2 units in the mark's colour (read, or write's vermilion): out of the disassembly's right rule level with the row, into the gutter's middle lane (x 956), up or down it to the word's height, and onto the stack's rule, a head 7 by 8 on the rule; the word's own mark is the end, so the line never crosses the pin lane's names |
-| `carry` | this value went from that word into this register, or from this register into that word | the source and the destination of a load or a store (a stack word, a dump's run or a loupe's row; a register's row); a push's register and its word, a pop's word and its register, a call's return row and its word. A scene's knob, `carry`: `off` (the default), `arrow` | a walked step, from the source's read to the destination's strike | 2 units in **primary** (a value has no region), its head an **open chevron** 7 by 8 drawn in two strokes: never a `link`, which is 3 units in the region's ink with a filled head and a pin riding it, and says "points at", not "went to". From the source's panel rule level with its row, along the gutter's right lane (x 962), onto the destination's rule. No digits travel on it |
-| ink, digits | these are one thing | an address anywhere and its row, node or name; a call's arguments on its span, its backtrace row and its node | always | no line |
+### The tables
+
+| Table | A row is | Its columns | Made |
+| --- | --- | --- | --- |
+| `places` | a thing on screen a relation can end on | id; its kind (`slot`, `reg` row, `insn` row, source `line`, a `bytes` run, a node, a cell, a pill, a loupe's row, a shelf's tag, a bubble); its address, memory or code, where it has one; its box; its panel; shown, or off its window above or below and how far | one pass over the panes' visible rows, when the moment or a window changes, then kept |
+| `values` | a value on screen that may be an address | id; the place it is shown in; the value; its region (stack, heap, code, data, none); its hop in its chain | one pass over every chain, field reading and annotation on screen, with `places` |
+| `events` | what the step does | its kind (fire, read, write, register set, push, pop, call, ret); its place; its frame in the step | from the recording's step |
+| `kinds` | a kind of relation | the table below | the catalogue's, fixed |
+| `knobs` | a kind's setting | the kind; `off`, `step`, `standing` (or its own values); the beat's `emphasis` | from the scene file, per scene and per beat |
+| `relations` | a relation found | kind; source place; target place; state (`quiet`, `standing`, `active`); priority; lane; its verb's frames | the resolver's output, per moment and window, cached; a frame between moments interpolates its verbs |
+
+A relation never reads a panel's layout: it joins places. States: `quiet`
+(found, not drawn: its echo and the names say it), `standing` (60% toward the
+page while a beat lasts), `active` (full ink, for the step that causes it).
+
+### The kinds
+
+| Kind | Says | Join (source ⋈ target) | Knob · default | Priority | Ink, form | Route | Verb, timings |
+| --- | --- | --- | --- | --- | --- | --- | --- |
+| `thread` | this line is these instructions, and the machine is here | the current `line` ⋈ the `insn` rows of that line | none · always | 0: never gives way | gold, 3; a `tie` bracket on the line and on each run | the left margin, x 54 (on the map, the gutter at x 1008) | standing; moves with `advance` |
+| `link` | this register now points at that | a struck `reg`'s value ⋈ `places` by address, where the target has a pin lane (a node, a slot) | `link`: `off`, `step` · `step` | 2 | the target region's ink, 3; a filled head; the pin rides it | the gutter's left lane up into the band, the right lane down to a slot | `link`: s+6, 24 f (36 over 400 units), back 18 |
+| `projection` | these bytes are that part of the drawing | a read or write `event`'s run ⋈ the drawing's part made of those bytes | `projection`: `off`, `step` · `step` where a lens with a view is up | 3 | the mark's colour, 2; a bracket at each end | the gutter's right lane; a lens's top or bottom lane | `project`: bracket 6 f, line 18 (30 over 600), back 18 |
+| `aim` | this word holds the address of that instruction | `values` of region code ⋈ `insn` rows (or a graph's pills) by address | `aim`: `off`, `step`, `standing` · `off` | 4 | code's ink, 2; a filled head; the row's address framed | the gutter's left lane, x 950 | `aim`: after its word's mark, 18 f (24 past ten rows); glide 24 to a new row; fray 12 + 18 |
+| `carry` | this value went from there to here | a load, store, push or pop `event`'s source ⋈ its destination | `carry`: `off`, `arrow`, `value` · `off` | 5 | primary, 2; an open chevron | the gutter's right lane, x 962 | `carry`: after the source's read, 18 f (24 past eight rows), back 18 with the strike |
+| `touch` | this instruction reads or writes that word | a read or write `event`'s `insn` row ⋈ the `slot` by address | `touch`: `off`, `step` · `step` under `annotation = .tied` | 6 | the mark's colour, 2; a head on the stack's rule | the gutter's middle lane, x 956 | `touch`: 12 f (18 past six rows), before the word reacts; back with the advance |
+| `arc` | this word points at that row of its own panel | `values` in a panel ⋈ `places` in the same panel by address | `arcs`: `off`, `standing` · `standing`, active in the step that writes or reads it | its panel's: lanes, not the frame's budget | the target region's ink, 2, 60%; full when touched | the panel's left lanes (three; the stack two) | `arc` |
+| `stem` | this text speaks of that | a bubble ⋈ the row or tag it is level with | `stems`: `off`, `rest` · `rest` in the [column](#column) | rests only: never with a step's lines | `dim`, 2 | across the gutter, level | in 12 f with the bubble, back 12 f with the fire |
+| a loupe's stem | this loupe is the memory round that pointer | a loupe ⋈ the hop it opened from | with the loupe, the author's beat | 1 | the region's ink, 3 | none: straight, over the row's empty end | `open`, `close` |
+| a dump's place | these bytes are there | a dump's rows ⋈ a band of [`segments`](#segments) | with `segments`, the introduction's | standing | stack's ink, 3, 60% | over the stage's top, y 56 | the chart in motion.md |
+| `echo` | these are one event | two places marked by one `event` at one frame | none · always | no line | the mark itself | none | the mark's |
+| `pin`, a `call` span, ink and digits | these are one thing | places whose address is a value shown (a pin); a frame's words (a span); any two places of one address | none · always | no line | on the target | none | `travel`, the span's |
+
+### Which kinds are on
+
+A kind is on by default only where it says what the step did, at the
+machine, where the eye already is, and the frame would mislead without it:
+the thread, the link, the projection, the arcs, the touch under `tied`, the
+column's stems, and the kinds that draw no line. Every kind that adds a
+reading of its own (where a value went, where a code pointer leads, which
+memory a loupe shows) is the author's to switch on, for a scene or a beat:
+`carry`, `aim`, a loupe's stem, a dump's place. **No kind is ever drawn
+because the budget has room for it**: the budget only removes.
+
+What a scene writes, for the scene or from a beat on:
+
+```zig
+s.relations(.{ .aim = .standing, .carry = .arrow }); // the scene, from here on
+cur.beat(s, .{ .relations = .{ .touch = .off }, // this beat only
+ .emphasis = .aim }); // and what it is about, first in the budget
+```
+
+### The resolver
+
+Six passes, each a loop over a table, in this order:
+
+1. **Candidates.** For each kind whose knob is not `off`, its join: values
+ against places by one lookup each in the moment's address index (`aim`,
+ `link`, `arc`, pins, ink and digits), or the step's events against places
+ (`touch`, `carry`, `projection`, the active state of any kind). Out: rows of
+ `relations`, `quiet`.
+2. **Knobs.** Each row takes its state from its kind's knob for the beat:
+ `standing` where the beat stands it, `active` where a step's event causes
+ it, else it stays `quiet`.
+3. **Priority.** Rows sorted: the thread; then the kind the beat names as its
+ `emphasis`; then the kinds' priorities; within a kind, the step's order.
+4. **Budget.** Rules over the sorted rows: the thread always; at most **two**
+ active rows that cross panes (three lines in the frame with the thread); at
+ most **one** standing row that crosses panes; stems only in a rest with no
+ active row; in a panel, its lanes. Rows past the budget go back to `quiet`
+ (their echo is the mark), the last first. A touch and a carry or an aim
+ leaving the same word are one gesture: the touch draws back as the other
+ leaves, and counts once.
+5. **Route.** Per channel (below), rows sorted by span, lanes given greedily,
+ the longest outermost, nested spans inside one another; a row that cannot
+ get a lane without crossing another, or a standing one, goes `quiet`. A row
+ whose target is off its window gets the stub (below). Labels are never in a
+ channel, so no route crosses one.
+6. **Draw.** Each row's verb at its frames: drawn in, held, drawn back,
+ interpolated per frame from the cached rows.
+
+**Off the window.** A relation whose target is outside its panel's window
+comes along its lane to the panel's nearest edge and ends on the panel's rule:
+a head pointing out of the panel, and beside it in faint mono 20 how far the
+target is (`12 rows`), or, for code, the name of the row (`main+50`). The
+stack's and a dump's windows scroll to a word a step touches before its
+relation draws; the disassembly's window never moves for a relation (it
+follows the pc). Where the target is in no pane at all, no line: the value's
+name carries it.
+
+**The map and the minimap.** On the map, where places are thousands, the
+thread and each panel's own arcs (standing, lane-capped as above) are all
+that is drawn: a step's relations are told in the working frame. A minimap
+draws no relation; an arc's end and an aim's target row are its marks, a
+1-unit tick in their ink.
+
+**Cost.** Bounded and small, on the map as in the working frame, nothing
+scanned once per relation: `places` and the address index are built once per
+moment and window; candidates are one lookup per value on screen and one per
+event, so the cost is the places and values on screen, never their product;
+only kinds whose knob is on are joined; routing is one sort per channel; the
+result is cached per moment and window position. The measure: on the map
+(some 4,000 places, 6,000 values) the six passes within 1 ms at 60 frames a
+second; in the working frame a tenth of that.
`call` spans and `pin`s are ties too, the kind that need no line because
they sit on their target.
@@ -1348,29 +1448,9 @@ bytes the call left in memory, and the node is the part of the drawing
made of them, which is what a projection says. A node and its frame are
also tied by digits, standing, through the arguments on the span.
-**Budget.** One `thread`, always. For a step, one `link` and one
-`projection`, or the stems of two [`loupe`s](#loupe) (a stem is a link), and
-a `touch` or a `carry` (with both knobs on, a load's touch draws back as its
-carry leaves the word, so the two are one gesture, one line at a time: the row
-reaches into memory and the value comes back; a store draws only its carry,
-the row having named the word). Never more than three drawn lines in the frame; a second pointer or
-a second run in the same step gets `echo` and pins. The touch is the first to
-give way: where a step draws a link and a projection it is an echo (the word's
-mark with the row's, at the same frame), its two ends being side by side and
-the name and the digits saying already that they are one. rsp never takes a
-link: its pin is on the window's top row by construction.
-[`establish`](#6-verbs) draws no lines. In the [`column`](#column)
-a bubble's stem stands only in the rest before a step, never with its ties.
-
-**Off the window.** A link whose target is outside its panel's window (a
-slot past the stack's last row) comes down its lane to the panel's
-nearest row, turns into the pin lane and ends on the panel's rule: a
-head 9 by 12 pointing out of the panel, and beside it in faint mono 20
-how far the target is, `12 rows`. The pin is drawn when the window
-reaches it.
+### Routes
-**Routes.** A tie runs only in channels, with corners of radius 8 (6 for a
-projection):
+A tie runs only in channels, with corners of radius 8 (6 for a projection):
| Channel | Carries |
| --- | --- |
@@ -1379,6 +1459,7 @@ projection):
| the gutter's right lane, x 962 | what keeps to its own height or goes down: a projection from the band's view to the drawing; a link from a register down to a slot |
| the gutter's right lane, x 962, between the stack and the registers | a carry: up from a word to a register, or down from a register to a word, both in the state column; its legs into the panels are level with the rows |
| the gutter's middle lane, x 956 | a touch, from a row of the disassembly to a word of the stack, within the height the two share (under the registers, so it never meets a link climbing into the band); where a link down to a slot holds the right lane over the same rows, the touch gives way to its echo rather than cross it |
+| the gutter's left lane, x 950, within the context's height | an aim: from a word in the state column across to a row of the disassembly; its legs level with the word and with the row, the head on the disassembly's right rule. In the column form, between a pane and the panes over it, the same lane, its head on the upper pane's right rule |
| a lens's bottom lane, 8 above its edge | what arrives from below: a link to the pin under its node; a projection to a call node |
| a lens's top lane, 4 under its tag | a projection from the view, to the bracket over its node's address |
| a panel's pin lane | a link's last leg to a `row` pin, or its stub |
@@ -1396,7 +1477,7 @@ under a node that has just been made there is only room for its own
children. The map draws the thread and no other tie: a link or a
projection is a step's, and steps are told in the working frame.
-**The carry, a knob.** A scene says `carry = .arrow` to draw the value's way
+**The carry.** A scene says `carry = .arrow` to draw the value's way
between memory and the registers; it is `off` unless a scene asks. Off by
default because at -O0 nearly every step is a load or a store, and with the
`touch`, the names, the offsets' digits and the strikes the move is already
@@ -1415,10 +1496,31 @@ introduction's one walked load, where the viewer first learns that a
register can hold what memory holds; never in a scene's ordinary steps
([mock 56](mock/56-carry.png)).
+**The aim.** Off unless the author turns it on (`aim = .step` or
+`.standing`, for a scene or a beat). On, it finds every value on screen that
+is a code address whose row is shown (a disassembly row, a descent window's
+row, a graph's pill holding the address), and draws for the word a step
+writes or reads (`.step`) or for the words the beat stands (`.standing`). In a
+step, cause before effect: the word reacts first (struck, or framed as read),
+then the aim draws from it to its row, 18 f (24 f past ten rows), `standard`
+(a touch on the same word draws back as the aim leaves it: one gesture, the
+row reaching the word and the word pointing back into code),
+and the row's address is framed in code's ink as the head lands; only then
+what follows (rsp's pin climbing onto a pushed return address; at a `ret`,
+the plaque's jump, which goes where the aim points, the aim drawing back as
+the plaque lands). When the word is written again: the new value is code with
+a row shown, the head glides to that row (24 f, `glide`) after the strike;
+code with no row shown, the head goes to the rule as a stub with the row's
+name; no longer code, the aim **frays**: it goes dashed (12 on 8) over 12 f
+and fades over 18 f. Standing, it rides its rows when they scroll, and a word
+that leaves its window takes it away. Route: out of the word's panel's left
+rule level with it, the gutter's left lane (x 950), onto the disassembly's
+right rule level with the row ([mock 57](mock/57-aim.png)).
+
**Order.** A tie arrives before the thing it points to reacts: see
-[`link`, `project` and `touch`](#6-verbs). Mock 9 shows the standing ties; 10 and
+[`link`, `project`, `touch`, `carry` and `aim`](#6-verbs). Mock 9 shows the standing ties; 10 and
11 all four; 12 the projection to a call; 21 a loupe's stem; 44 to 47 the
-touch, 48 the touch against an echo alone and against a name in the operand.
+touch, 48 the touch against an echo alone and against a name in the operand; 56 the carry; 57 the aim.
## 5. The frame
@@ -2069,6 +2171,7 @@ Frames at 60 a second. `s` is the frame a strike lands. Curves:
| `project` | a run read or struck, and its part of the drawing | on the run's mark: the bracket on the row (6 f), the line draws from the bytes to the drawing (18 f; 30 f over 600 units; `standard`); only when it arrives does the part react (its own `read`, or `arm` and `strike`; a new call's node fades in, 6 f); out with the advance, 18 f |
| `touch` | the current row and the stack word it reads or writes (`tied`) | right after the fire, before anything the word causes: the line draws from the row's end across the gutter to the word's row, head first, 12 f (18 f when its leg is longer than six rows), `standard`; only when the head has landed is the word armed (a write: 12 f, then struck) or framed (a read, 6 f); only after that does what follows from the word move (a register it fills, rsp's pin climbing onto a pushed word, a span, a role). Held to the advance; drawn back into the row with it, 12 f, or (with `carry` on, for a load) as the carry leaves the word. A store of the value the word already held: the head lands, the arm's frame comes and goes and nothing is struck. A word the window must scroll to: the scroll first, then the touch. At a run and a sprint none: the names stand, and the marks are the run's |
| `carry` | a value's way from its source to its destination (`carry = .arrow`) | the source framed `read` first (a register 6 f; a word by its touch); then the arrow draws from it to the destination, head first, 18 f (24 f past eight rows), `standard`; on its landing the destination is armed (12 f) and struck; the arrow draws back as the strike lands (18 f); only then what follows (a link from the register filled, a pin's travel). At a run and a sprint none |
+| `aim` | a code address and its row (`aim = .step` or `.standing`, the author's) | after the word's own strike or read: the line draws from the word to the row, head first, 18 f (24 past ten rows), `standard`, the row's address framed in code's ink as it lands (6 f); held to the advance, or standing at 60% through the beat; a word written again: the head glides to the new row (24 f, `glide`), goes to the rule as a stub with the row's name, or frays (dashed 12 f, then out 18 f) when the value is no longer code; at a `ret`, the plaque jumps where it points and the aim draws back as it lands. At a run and a sprint none |
| `follow` | the stack's window, after rsp's pin | only once the pin has landed and never with it: where the headroom over rsp is under two free words, or the newest frame's return address under the window's foot, the rows glide by whole slots, 24 f and 2 f a further slot, 36 f at most, `glide`, the pins riding their rows, the strip's window with them. A climb longer than the room over the pin is one move: the pin travels to the window's top, and the rows take the rest of the distance under it on the same curve. Farther than the window: `unroll`, the pin along the column, `roll` |
| `travel` | a value, a card or a pin going from one place to another | `glide`. A value or card: 30 f to 200 units, 36 f to 400, 48 f beyond. A pin goes along its lane, 18 f after the strike that moved it: in a drawing 30 f to the next node or cell, 36 f to one farther; in the stack's lane 24 f to the next row and 2 f a further row, 36 f at most. A pin that comes fades in over 12 f rising 8 units; one that goes fades out over 12 f; a name joining or leaving a pin cross-fades over 12 f. On a `link` the pin rides the line's head instead. 8 f at a run; at a sprint only at a phrase's end. **rsp's and rbp's pins** are the stack's event and are given time: 24 f to the next row and 6 f a further row, 48 f at most, `glide`; the amount on the pin from its first frame, counting as it crosses each row (`rsp -8`, `-10`, `-18`, in write's vermilion, bold), held to the advance and then crossfading to the bare name (12 f); each row it reaches gained (brightening from `free`, 12 f, from the frame the pin's head reaches it, its role fading in with it) or released (to `free`, 12 f); the bracket over the rows crossed drawing with it; the newest span's end riding it; the register struck as the pin lands, and the row's amount with it. rbp's flight to rsp's row: the same, the names meeting in pwndbg's order (rsp slides aside, 12 f, before rbp lands). At a run: 8 f and 2 f a row, 16 f at most, drawn over the veil (the pins, the bracket, the span and the rows' gain or release stand clear of it; the rest of the stack stays veiled), no amount; at a sprint, on the map, rsp is the edge of the stack column's newest frame, moving with each moment (4 f), the spans growing and shrinking with it |
| `open` | a loupe, from a pointer | the pointer's hop framed `read` (6 f); the stem draws from it to the loupe's place, head first, 18 f (30 f over 600 units), `standard`; the loupe rises with the stem's head: it fades in over 12 f from 8 units lower, its shadow growing from nothing to its offset (18 f, `standard`); the target's bright frame lands 6 f after. From a pointer inside a loupe the same, over it, and a third closes the first as it starts. In the slot of the level that read the pointer, or on a beat the caption names |
@@ -2221,7 +2324,7 @@ python3 -B map.py && for n in 09-context 10-context-step 11-context-lens 21-loup
resvg $n.svg $n.png && resvg -w 480 $n.svg $n-480.png; done # 20-dive.png it composes itself
resvg -w 1920 19-map.svg 19-map-1080.png
python3 -B gen.py # 1 to 8, then resvg the same way
-python3 -B touch.py # 44 to 48 and 56 (it runs resvg and composes its sheets itself)
+python3 -B touch.py # 44 to 48, 56 and 57 (it runs resvg and composes its sheets itself)
python3 -B column.py # 49 to 55 (the same)
```
@@ -2236,6 +2339,7 @@ python3 -B column.py # 49 to 55 (the same)
| [47](mock/47-tied-prologue.png) | reverse's prologue, six instants numbered in their order | `push rbp`: 1 the touch to the free word, 2 the word written (rbp's own value: the arm's frame, no strike), 3 rsp's pin onto it, `saved rbp` arriving; `mov rbp, rsp`: 4 rbp's pin flown from main's saved rbp to rsp's row, the two meeting, the base to rbp; `sub rsp, 0x18`: 5 the climb at its first row, `-8`, 6 landed at `-18`, three words gained, the rows slid under the pin for the last of it |
| [48](mock/48-tied-ways.png) | the sheet: three ways to say the row and its word are one thing, on 44's instant | A, names and the echo alone, pwndbg's offsets; B (recommended, `tied`), names, offsets from the frame's base and the touch; C, the name in the operand as IDA writes it, the row saying only what moved |
| [56](mock/56-carry.png) | `carry = .arrow` with `tied`, six instants numbered in their order: the load `mov rcx, [rbp - 8]`, then the store `mov [rbp - 0x18], rax` | the load: 1 the touch and `prev` read, rcx untouched; 2 the touch withdrawn as the carry climbs the gutter's right lane to rcx, its open chevron landing, rcx armed; 3 rcx struck, the carry gone, rcx's link to its pin. The store: 4 rax framed read, memory unmoved; 5 the carry down to `next`'s word, armed on its landing; 6 struck |
+| [57](mock/57-aim.png) | `aim = .step` on `call reverse`, the instant after the return address is struck (46's third instant) | the touch drawn back as the aim leaves the word: from the return address up the gutter's left lane onto the disassembly's right rule at `401272`, the row after the call, its address framed in code's ink; rsp's pin not yet moved |
| [49](mock/49-column-call.png) | the column: `open`'s call (`hello`, moments 37 to 38), mid-step | the `shelf` (the log, its bytes, the registers with rsp struck on their tag); source 3, main's window, a stack of nineteen words; the touch down the gutter onto the stack's right rule; the newest bubble on its paper, level with the call row, the older one dimmed above it |
| [50](mock/50-column-stub.png) | the stub's `jmp` (38), the rest before its step | the descent in the column with the stack kept under it, the return address held on its top; the bubble's stem across the gutter to the jmp row |
| [51](mock/51-column-args.png) | libc's `open`, its last three walked (61 to 64), mid-step of `mov eax, 0x101` | the registers unfolded under the descent, rip's row above 888; the bubble level with the first of the three |
@@ -2569,6 +2673,14 @@ is not checked here. The tokens are under [Token changes](#token-changes).
no touch; nothing for a move between registers; a stub to a folded or
off-window end.
+17. **Relations as one system** ([ties](#4-ties)), built as data: per frame,
+ the tables of places and of values, the kinds' table as the catalogue
+ gives it, relations as joins between them, and the resolver as a pipeline
+ of passes (candidates, knobs, priority, budget, route, draw), each pass a
+ loop over a table; the cost within 1 ms on the map. The new kind, `aim`
+ (off by default, the author's): code's ink, the gutter's left lane, the
+ row's address framed; held, moved or frayed as its word is written.
+
**What the recordings must hold**, with the tracer's options:
- For the map, as before: `--stack 1024`, `--disasm 69`, `--around 256`;
@@ -2668,6 +2780,8 @@ and `metric.bytes` and `metric.slot`'s new columns are in, as asked.
| `time.sp_travel` | `time.pin` (24 f, 2 f a row, 36 at most) for every pin | rsp's and rbp's: 0.40, 0.10 a further row, 0.80 at most (`glide`); the amount's crossfade 0.20 at the advance; a row's gain or release 0.20; at a run 0.13, 0.03 a row, 0.27 at most |
| `time.follow` | none | after the landing: 0.40, 0.03 a further slot, 0.60 at most (`glide`) |
| `metric.carry`, `time.carry` | none | 2 in primary, an open chevron 7 by 8 in two strokes; the gutter's right lane, 962; the source's read 0.10, the arrow 0.30 (0.40 past eight rows), the destination's arm 0.20 and strike, back 0.30 with it; `carry = .value`: a chip of `raised`, mono 20, on the head |
+| `metric.aim`, `time.aim` | none | 2 in code's ink, a filled head 7 by 8 on the disassembly's right rule, the row's address framed 2 in code's ink; the gutter's left lane, 950; 0.30 (0.40 past ten rows), `standard`; a new row 0.40 (`glide`); fraying: dashed 0.20, out 0.30; standing at 60% |
+| `relations` | each kind its own | the kinds' table ([ties](#4-ties)); the budget: the thread, two active, one standing across panes; the pass within 1 ms on the map |
| `metric.column` | none | the panes at 64 and the text at 976, 880 each; the shelf at 48, 24 high, its tags 12 apart; the panes from 84, narrated rows above 888, the floor to 1032; the clock under the text column at 900 |
| `metric.bubble` | none | Go 40 on 54, code mono 35; 40 characters and three lines at most; padding 16, 812 wide at most; the newest on `raised`, older ones `dim` and bare; three at most; 12 between bubbles; the stem 2 in `dim`, a head 7 by 8 |
| `time.bubble` | none | in 0.30 rising 8 (`enter`), out 0.20; dim 0.30; out of the newest's way 0.40 (`glide`); the stem 0.20 in with the bubble, 0.20 back with the fire; between beats: fold 0.20 then 0.40 (the panel closing as its tag travels to the shelf), the stayers 0.40, unfold 0.40 (the tag back as the panel opens) then 0.20 |