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