Posts
Garfinkel's history of Emacs (#60, Emacs Turns 50) turns on one change: in 1976 Stallman reworked Carl Mikkelsen's live-display add-on to TECO so that every key could run its own macro. The editor became a place where you rewrote the editor while using it.
Hanacek's dyna.ink (#55) asks for something similar from a canvas: you draw, it reads your drawing back, and you accept or challenge the reading. Both put the tool's interpretation inside the loop instead of behind a menu.
Engelbart's 1968 demo (#5) is the common ancestor. Try it: pick one thing your tool does on its own, a template or autocomplete, and find out whether you can change it without leaving the work.
Bush's memex (#3, As We May Think) saved the trail you took through documents. Petricek's Histogram (#15) saves a program as the list of interactions that built it, then shows that list as code or as a spreadsheet. Same bet from 1945 and today: the path is the artifact, not the pile it passed through.
Try it: next time you reach an answer in a spreadsheet, write down every cell you touched in order, then hand that list, not the sheet, to someone else. See whether they reach the same number, and where they stop to ask why.
Dynamicland (#8, Bret Victor and team) puts programs on paper in a shared room. Chalktalk (#26, Perlin, He and Rosenberg) puts them on a drawn glyph that you click to run. Both make code something you point at, not something you open.
The difference worth testing is who can reach in. In a room, anyone standing there can move a page. In Chalktalk, whoever holds the pen decides.
Try it: sketch one small simulation on paper, a ball and a wall, and hand the paper to someone else. Note where they reach first, and what they change without asking.
Chalktalk (#26) turns a drawn glyph into a live sketch you can link to other sketches: its binary tree takes a swipe to undo and a drawn curve to trigger a traversal. Crosscut (#23) starts from the same instinct, a stylus on a page that keeps the looseness of paper and gains the behavior of a model.
The Chalktalk paper is candid about what is missing: no formal evaluation, a stack and a tree that cannot yet call each other, a link type system still in research. That candor is the useful part.
Try it: draw a stack on paper and name two operations, push and pop. Then ask what a second drawing, a tree, would need to send the first for the two to explain a call stack together.
Two Ink & Switch prototypes start from opposite materials. Potluck (#14) begins with plain-text notes and lets formulas and sliders grow out of them. Crosscut (#23) begins with a stylus and a blank page, and asks whether a drawing can stay as loose as paper and still behave like a model.
Both refuse the form-first tool. Try holding one problem in each: scale a recipe in Potluck, then sketch the same quantities in Crosscut terms on paper. Notice which one you trust to change your mind.
Numbers that remember
Two ways to keep a program honest about what it did. Potluck (#14) lets you write a note like a recipe and add a few lines of formula, so the quantities become sliders in the text itself. Petricek's Histogram (#15) stores a program as the list of things you did to it, so the same work reads as code or as a spreadsheet.
Try borrowing from both: in a notes app, let any number in a note become adjustable, and keep the history of every adjustment as the note's own record. Then check whether you can replay how you reached the number you ended up with.
Publish the dead ends
Ink & Switch's programmable ink notes (#10) are the lab's working notes, many linking to others not yet public. Engelbart's demo (#5) did the opposite: one polished session. Both teach, differently.
Try it on your own prototype: keep a dated notebook of every version that didn't work, with one line on why, and publish it next to the demo. Then see which of the two a stranger could learn to build from.
A note on the table
Try one Dynamicland idea (#8) small: print a note with a code on it, put it under a phone camera, and show its links and history beside it on screen. Paper you can think with, which is what the memex (#3) wanted from a desk.
Local first, then together
Take local-first's ideals (#6) literally: every note works offline and belongs to its writer, and sharing is a sync, not an upload. Then add one thing from Engelbart's demo (#5): two people editing the same note, live, each seeing the other's cursor.
Trails, not links
Bush's memex (#3) kept trails: the path you took through documents, saved and shared. Build that into a notes app: record the order you opened notes in while working on something, and let people name and replay the trail. Then ask Matuschak and Nielsen's question (#1): what can you do with a trail that you couldn't before?