10arvo is composed of modules called vanes:
12<list dataPreview="true"></list>
16At a high level `%arvo` takes a mess of unix io events and turns them
17into something clean and structured for the programmer.
19`%arvo` is designed to avoid the usual state of complex event networks:
20event spaghetti. We keep track of every event's cause so that we have a
21clear causal chain for every computation. At the bottom of every chain
22is a unix io event, such as a network request, terminal input, file
23sync, or timer event. We push every step in the path the request takes
24onto the chain until we get to the terminal cause of the computation.
25Then we use this causal stack to route results back to the caller.
30The `%arvo` causal stack is called a `++duct`. This is represented
31simply as a list of paths, where each path represents a step in the
32causal chain. The first element in the path is the first letter of
33whichever vane handled that step in the computation, or the empty span
36Here's a duct that was recently observed in the wild:
39 /g/a/~zod/4_shell_terminal/u/time
40 /g/a/~zod/shell_terminal/u/child/4/main
41 /g/a/~zod/terminal/u/txt
46This is the duct the timer vane receives when "timer" sample app asks
47the timer vane to set a timer. This is also the duct over which the
48response is produced at the specified time. Unix sent a terminal
49keystroke event (enter), and arvo routed it to %dill(our terminal),
50which passed it on to the %gall app terminal, which sent it to shell,
51its child, which created a new child (with process id 4), which on
52startup asked the timer vane to set a timer.
54The timer vane saves this duct, so that when the specified time arrives
55and unix sends a wakeup event to the timer vane, it can produce the
56response on the same duct. This response is routed to the place we
57popped off the top of the duct, i.e. the time app. This app produces the
58text "ding", which falls down to the shell, which drops it through to
59the terminal. Terminal drops this down to dill, which converts it into
60an effect that unix will recognize as a request to print "ding" to the
61screen. When dill produces this, the last path in the duct has an
62initial element of the empty span, so this is routed to unix, which
65This is a call stack, with a crucial feature: the stack is a first-class
66citizen. You can respond over a duct zero, one, or many times. You can
67save ducts for later use. There are definitely parallels to Scheme-style
68continuations, but simpler and with more structure.
73If ducts are a call stack, then how do we make calls and produce
74results? Arvo processes "moves" which are a combination of message data
75and metadata. There are two types of moves. A `%pass` move is analogous
78 [duct %pass return-path=path vane-name=@tD data=card]
80Arvo pushes the return path (preceded by the first letter of the vane
81name) onto the duct and sends the given data, a card, to the vane we
82specified. Any response will come along the same duct with the path
85A `%give` move is analogous to a return:
87 [duct %give data=card]
89Arvo pops the top path off the duct and sends the given card back to the
95As shown above, we use arvo proper to route and control the flow of
96moves. However, arvo proper is rarely directly responsible for
97processing the event data that directly causes the desired outcome of a
98move. This event data is contained within a card, which is simply a
99`(pair term noun)`. Instead, arvo proper passes the card off to one of
100its vanes, which each present an interface to clients for a particular
101well-defined, stable, and general-purpose piece of functionality.
103As of this writing, we have seven vanes, which each provide the
106- `%ames` name of both our network and the vane that communicates over
108- `%clay` version-controlled, referentially- transparent, and global
110- `%dill` terminal driver. Unix sends keyboard events to `%dill` from
111 either the console or telnet, and `%dill` produces terminal output.
112- `%eyre` http server. Unix sends http messages to `%eyre`, and
113 `%eyre` produces http messages in response
114- `%ford` handles resources and publishing
115- `%gall` manages our userspace applications.. `%gall` keeps state and
117- `%time` a simple timer
122Cards are the vane-specific portion of a move. Each vane defines a
123protocol for interacting with other vanes (via arvo) by defining four
124types of cards: kisses, gifts, notes, and signs.
126When one vane is `%pass`ed a card in its `++kiss`, arvo activates the
127`++call` gate with the card as its argument. To produce a result, the
128vane `%give`s one of the cards defined in its `++gift`. If the vane
129needs to request something of another vane, it `%pass`es it a `++note`
130card. When that other vane returns a result, arvo activates the `++take`
131gate of the initial vane with one of the cards defined in its `++sign`.
133In other words, there are only four ways of seeing a move: (1) as a
134request seen by the caller, which is a ++note. (2) that same request as
135seen by the callee, a `++kiss`. (3) the response to that first request
136as seen by the callee, a `++gift`. (4) the response to the first request
137as seen by the caller, a `++sign`.
139When a `++kiss` card is passed to a vane, arvo calls its `++call` gate,
140passing it both the card and its duct. This gate must be defined in
141every vane. It produces two things in the following order: a list of
142moves and a possibly-modified copy of its context. The moves are used to
143interact with other vanes, while the new context allows the vane to save
144its state. The next time arvo activates the vane it will have this
145context as its subject.
147This overview has detailed how to pass a card to a particular vane. To
148see the cards each vane can be `%pass`ed as a `++kiss` or return as a
149`++gift` (as well as the semantics tied to them), each vane's public
150interface is explained in detail in its respective overview.
keysesc to close
- j k
- move down, up
- enter
- open
- esc
- back, or up a level
- 1 2 3 4
- readme, files, commits, refs
- /
- filter
- y
- copy the clone command
- c
- compare the chosen commit with another (or shift-click both)
- ?
- show or hide this list