<feed xmlns='http://www.w3.org/2005/Atom'>
<title>computeranim.git/design/mock/context.py, branch main</title>
<subtitle>Tracing debugger and animations of running programs (ztrace, canim)</subtitle>
<id>https://git.0x4200.cafe/computeranim.git/atom?h=main</id>
<link rel='self' href='https://git.0x4200.cafe/computeranim.git/atom?h=main'/>
<link rel='alternate' type='text/html' href='https://git.0x4200.cafe/computeranim.git/'/>
<updated>2026-11-12T10:28:53Z</updated>
<entry>
<title>design: the introduction's storyboard as built</title>
<updated>2026-11-12T10:28:53Z</updated>
<author>
<name>Gabriel Schneider</name>
<email>gbrls@0x4200.cafe</email>
</author>
<published>2026-11-12T10:03:05Z</published>
<link rel='alternate' type='text/html' href='https://git.0x4200.cafe/computeranim.git/commit/?id=2311d3617ee17a89b647fea722c47ec739fd63f3'/>
<id>urn:sha1:2311d3617ee17a89b647fea722c47ec739fd63f3</id>
<content type='text'>
The storyboard and catalogue follow what the introduction became after
its review: the plain build, chapter II's six beats with the stack's
convention said and the call before the push, the regroup's bytes flying
one at a time over their row, the dump folding into its tag, the Eiffel
visit at x2 with the 128 bytes marked, hex offsets, names only after
the things. The aim's head is 10; a beat's link fades its head as it
draws back. Mocks 29, 30, 31 and 37 redrawn.

Co-Authored-By: Claude Opus 5.5 &lt;noreply@anthropic.com&gt;
Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
</content>
</entry>
<entry>
<title>design: the disassembly tied to the stack; rsp's moves seen; a column of text as an experiment</title>
<updated>2026-11-11T22:35:09Z</updated>
<author>
<name>Gabriel Schneider</name>
<email>gbrls@0x4200.cafe</email>
</author>
<published>2026-11-11T22:11:00Z</published>
<link rel='alternate' type='text/html' href='https://git.0x4200.cafe/computeranim.git/commit/?id=cc2059e39047cafe1886dc17084855ddd0c52b01'/>
<id>urn:sha1:cc2059e39047cafe1886dc17084855ddd0c52b01</id>
<content type='text'>
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 &lt;noreply@anthropic.com&gt;
Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
</content>
</entry>
<entry>
<title>design: the disassembly stays under the source; the graph as a track</title>
<updated>2026-11-11T17:17:51Z</updated>
<author>
<name>Gabriel Schneider</name>
<email>gbrls@0x4200.cafe</email>
</author>
<published>2026-11-11T17:17:43Z</published>
<link rel='alternate' type='text/html' href='https://git.0x4200.cafe/computeranim.git/commit/?id=4862e778af7779bbdb047b9c71adfb62add319b2'/>
<id>urn:sha1:4862e778af7779bbdb047b9c71adfb62add319b2</id>
<content type='text'>
From the user, on the sort render. Registers a scene never changes fold
three to a row, so the stack is twelve to fifteen slots and the
disassembly keeps its place under the source with eleven to seventeen
rows; a blocks lens has no view. The graph leaves the layered picture of
the reverse-engineering tools: blocks are pills on one line in the order
they run, a loop an arch over its blocks with the turn count at its
centre, every bend a quarter circle; sort's eleven blocks and both loops
are seen whole across the band. Sheets 42 and 43 set the layouts and the
graph's forms side by side.

Co-Authored-By: Claude Fable 5.2 &lt;noreply@anthropic.com&gt;
Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
</content>
</entry>
<entry>
<title>design: the overflow as bytes; a minimap in each pane</title>
<updated>2026-11-11T16:22:07Z</updated>
<author>
<name>Gabriel Schneider</name>
<email>gbrls@0x4200.cafe</email>
</author>
<published>2026-11-11T15:49:15Z</published>
<link rel='alternate' type='text/html' href='https://git.0x4200.cafe/computeranim.git/commit/?id=576a78b4de02c4c6566c327d85c465554d293975'/>
<id>urn:sha1:576a78b4de02c4c6566c327d85c465554d293975</id>
<content type='text'>
From the user. In the pair a frame is a dump of eight bytes a row read
by its own fields, so each turn of the loop is one more letter and the
letters are seen to cross from buf into the saved rbp and the return
address, which reads as code until they reach it. Each pane with more
than it shows carries its own minimap, a strip of its column of the map
at four units a row with the pane's window outlined and what happens off
the window marked there; the corner minimap is gone, and in the dive
each column of the map folds into its pane's strip.

Co-Authored-By: Claude Fable 5.2 &lt;noreply@anthropic.com&gt;
Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
</content>
</entry>
<entry>
<title>design: the graph of a function's blocks; two runs as a pair</title>
<updated>2026-11-11T13:40:03Z</updated>
<author>
<name>Gabriel Schneider</name>
<email>gbrls@0x4200.cafe</email>
</author>
<published>2026-11-11T13:38:37Z</published>
<link rel='alternate' type='text/html' href='https://git.0x4200.cafe/computeranim.git/commit/?id=6142fa676731e158622ca7956c150c58bc57f1f2'/>
<id>urn:sha1:6142fa676731e158622ca7956c150c58bc57f1f2</id>
<content type='text'>
From the user. The disassembly's alternate form at a larger scale is the
graph of its basic blocks: a block a box of rows with its offset, lines
and visit count; execution flows down and a back edge is the one thing
that climbs, in its loop's lane with the turn count; what the run never
reached folds away. On the map it takes the disassembly's place; in the
working frame a blocks lens draws its shape and the rows are its view.
Verbs leave and turn carry the mark along an edge.

Two runs of one program share a frame as a pair: the seam is the gutter,
the source shared above, rows only one run has and values that differ
marked at the seam. The scene it is made for sets a plain build against
an ASan one in a stack overflow: the frame beside its shadow bytes, the
store beside its check, and the step where they part.

Co-Authored-By: Claude Fable 5.2 &lt;noreply@anthropic.com&gt;
Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
</content>
</entry>
<entry>
<title>design: what the second review found, placed</title>
<updated>2026-11-11T05:11:12Z</updated>
<author>
<name>Gabriel Schneider</name>
<email>gbrls@0x4200.cafe</email>
</author>
<published>2026-11-11T05:11:12Z</published>
<link rel='alternate' type='text/html' href='https://git.0x4200.cafe/computeranim.git/commit/?id=64e64c74be6a3e46abeae8a30dd42efff91aaf91'/>
<id>urn:sha1:64e64c74be6a3e46abeae8a30dd42efff91aaf91</id>
<content type='text'>
A caller keeps one row after its call and its callee sits under it;
opening and closing fade what is given up before what is kept glides,
and nothing changes in one frame. A system call stepped over is three
parts: the registers set, the crossing from the call row, the stores
after it. A loupe never covers a row its step changes, hangs over the
stack when opened from a view, and closes with the advance. A run draws
no strikes and no arcs, and a caption never names what the pace veils;
the heap scene's captions have landing and leaving frames. The map's
boxes are as tall as their rows. The veiled map travels into the
minimap. The motion instrument checks captions and fires POP on any
one-frame change after stillness.

Co-Authored-By: Claude Fable 5.2 &lt;noreply@anthropic.com&gt;
Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
</content>
</entry>
<entry>
<title>design: down is deeper; a call followed down; operands without size words; the heap as a scene</title>
<updated>2026-11-11T02:34:16Z</updated>
<author>
<name>Gabriel Schneider</name>
<email>gbrls@0x4200.cafe</email>
</author>
<published>2026-11-11T02:25:40Z</published>
<link rel='alternate' type='text/html' href='https://git.0x4200.cafe/computeranim.git/commit/?id=2a97030c9743d4680d698414c28e8d8739614215'/>
<id>urn:sha1:2a97030c9743d4680d698414c28e8d8739614215</id>
<content type='text'>
From the user. Direction and nearness are rules: the idea, the source,
its instructions, the callee and the kernel go down the frame, a call
goes down and a return comes up, and every tie runs one of those ways.
The disassembly can descend: a window a call depth, the caller keeping
three rows with its call waiting, a PLT stub its jump, the kernel at the
bottom on vellum, with verbs descend, cross and ascend. The kernel leaves
the band, which keeps the calls so far as strace writes them; the
backtrace has its newest frame at the bottom. Size words are dropped
from operands and a width is shown as byte cells where nothing else says
it; a compare shows its values and flags, a jump the flags it reads, an
indirect call its target and the slot it was read from. libc's heap is a
scene of blocks that exist (a dump by fields with a size and a protected
pointer read, arcs as the free list, a loupe into the tcache, the list
drawn over malloc's own), storyboarded on glibc 2.44. Mocks 16 to 18.

Co-Authored-By: Claude Fable 5.2 &lt;noreply@anthropic.com&gt;
Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
</content>
</entry>
<entry>
<title>design: arc, a pointer to a row of its own panel is drawn</title>
<updated>2026-11-11T01:51:17Z</updated>
<author>
<name>Gabriel Schneider</name>
<email>gbrls@0x4200.cafe</email>
</author>
<published>2026-11-11T01:50:34Z</published>
<link rel='alternate' type='text/html' href='https://git.0x4200.cafe/computeranim.git/commit/?id=fa5d150ac6977264f0704e9af664f8150bd25127'/>
<id>urn:sha1:fa5d150ac6977264f0704e9af664f8150bd25127</id>
<content type='text'>
From the user, on the loupe's mock: a pointer in memory named a row two
above it and nothing showed it. In a dump, a loupe and the stack a
pointer whose target is a row of the same panel is an arc in a lane at
the panel's edge, as a jump is in the disassembly: quiet while it stands,
full ink in the step that writes or reads it, a stub when the target is
just off the window. A chain shares a lane. A loupe carries the arcs
among its own rows; the stack's frame chain gets one only when touched.

Co-Authored-By: Claude Fable 5.2 &lt;noreply@anthropic.com&gt;
Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
</content>
</entry>
<entry>
<title>design: the dense stage is a map; the frame keeps its layout and gains a minimap</title>
<updated>2026-11-11T01:43:41Z</updated>
<author>
<name>Gabriel Schneider</name>
<email>gbrls@0x4200.cafe</email>
</author>
<published>2026-11-11T01:43:41Z</published>
<link rel='alternate' type='text/html' href='https://git.0x4200.cafe/computeranim.git/commit/?id=f0180748b19eac5fe99124142aea60eac78cf4bd'/>
<id>urn:sha1:f0180748b19eac5fe99124142aea60eac78cf4bd</id>
<content type='text'>
From the user, on the 4K mocks: the space was not well used, and the
dense view is better as where a scene starts or as a minimap than as the
frame it works in. The map is the same moment with every panel at full
length on 3840 by 2160, packed by content. The working frame is the 1920
stage again, each panel a window on its column of the map, with the map
at a twentieth in the caption band: windows outlined, marks no window
shows flashing there. dive and surface carry a scene between the two,
each window travelling to its panel's place. The loupe hangs from its
pointer in the working frame. Mocks 16 to 18 are withdrawn; 19 is the
map, 20 the dive in four instants, 21 a loupe with the minimap.

Co-Authored-By: Claude Fable 5.2 &lt;noreply@anthropic.com&gt;
Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
</content>
</entry>
<entry>
<title>design: four times the context on a 4K stage; the loupe; quieter marks</title>
<updated>2026-11-11T01:26:21Z</updated>
<author>
<name>Gabriel Schneider</name>
<email>gbrls@0x4200.cafe</email>
</author>
<published>2026-11-11T01:16:50Z</published>
<link rel='alternate' type='text/html' href='https://git.0x4200.cafe/computeranim.git/commit/?id=bbabc78dcfd00a98abb5ececae6761bccc496eb8'/>
<id>urn:sha1:bbabc78dcfd00a98abb5ececae6761bccc496eb8</id>
<content type='text'>
From the user, after the second videos. The stage is 3840 by 2160 at the
same type size: four columns (source, disassembly, state, stack), 69
lines, rows and slots with no lens, 43 with a lens as subject, dumps of
32 rows. Code reads at 1440p and up; the caption, the clock and a lens's
drawing are doubled, and the camera at x2 is the old frame. The stack's
rows carry their offset from rsp and a role. A loupe is the telescope as
a floating panel: the memory round what a pointer leads to, lifted over
the context, a pointer inside it opening the next. The current row is a
white wash, a strike a softened vermilion, held a turned corner; sheet 15
sets the alternatives side by side.

Co-Authored-By: Claude Fable 5.2 &lt;noreply@anthropic.com&gt;
</content>
</entry>
</feed>
