920 lines
139 KiB
HTML
920 lines
139 KiB
HTML
<!DOCTYPE html>
|
||
<html><head><meta charset="utf-8"/><title>Conversational Concurrency</title><link rel="stylesheet" href="reveal.js-3.6.0/css/reveal.css"/><link rel="stylesheet" href="presentation.css"/></head><body><div class="reveal">
|
||
<div class="slides">
|
||
<section data-transition="none" class="stage-0"><H3>Conversational Concurrency</H3><SPAN class="all-small-caps">Tony Garnock-Jones</SPAN><P><SMALL style="line-height: 1.5">PhD Dissertation Defense<BR/>December 8th, 2017</SMALL></P></section>
|
||
<section data-transition="none" class="stage-0"><section data-transition="none" class="stage-0"><P class="ghosted">more than one thing to do</P><H3 class="reddish">Concurrency</H3><P>vs.</P><H3 class="green">Parallelism</H3><P class="ghosted">progress on more than one <EM>at once</EM></P><aside class="notes"><div data-markdown="">Concurrency - many tasks
|
||
|
||
Parallelism - speed</div></aside></section>
|
||
<section data-transition="none" class="stage-1"><P>more than one thing to do</P><H3 class="reddish">Concurrency</H3><P>vs.</P><H3 class="green">Parallelism</H3><P>progress on more than one <EM>at once</EM></P><aside class="notes"><div data-markdown="">Concurrency - many tasks
|
||
|
||
Parallelism - speed</div></aside></section></section>
|
||
<section data-transition="none" class="stage-0"><P>Simon Marlow:</P><BLOCKQUOTE>Concurrency is [...] for structuring your program as a collection of
|
||
interacting agents. Parallelism, on the other hand, is just about
|
||
making your programs go faster.</BLOCKQUOTE><P><SMALL><a href="https://mail.haskell.org/pipermail/haskell-cafe/2008-September/047312.html">(in a 2008 post to the Haskell-Cafe mailing list)</a></SMALL></P></section>
|
||
<section data-transition="none" class="stage-0"><section data-transition="none" class="stage-0"><P>more than one <span class="highlighted">interacting</span> thing</P><H3 class="reddish">Concurrency</H3><DIV class="switch-container" style="height: 8em;"><DIV><P>vs.</P><H3 class="green">Parallelism</H3><P>progress on more than one <EM>at once</EM></P></DIV></DIV><aside class="notes"><div data-markdown="">This work:
|
||
- focus on *concurrency*
|
||
- takes a particular perspective</div></aside></section>
|
||
<section data-transition="none" class="stage-1"><P>more than one interacting thing</P><H3 class="reddish">Concurrency</H3><DIV class="switch-container" style="height: 8em;"></DIV><aside class="notes"><div data-markdown="">This work:
|
||
- focus on *concurrency*
|
||
- takes a particular perspective</div></aside></section>
|
||
<section data-transition="none" class="stage-2"><P class="ghosted">more than one <span class="highlighted">interacting</span> thing</P><H3 class="reddish">Concurrency</H3><DIV class="switch-container" style="height: 8em;"><DIV><P>is about</P><UL><LI>groups of components</LI><LI>working together</LI><LI>to achieve some shared goal.</LI></UL></DIV></DIV><aside class="notes"><div data-markdown="">This work:
|
||
- focus on *concurrency*
|
||
- takes a particular perspective</div></aside></section>
|
||
<section data-transition="none" class="stage-3"><P class="ghosted">more than one interacting thing</P><H3 class="reddish">Concurrency</H3><DIV class="switch-container" style="height: 8em;"><DIV><P>is about</P><H3 class="green">cooperation.</H3></DIV></DIV><aside class="notes"><div data-markdown="">This work:
|
||
- focus on *concurrency*
|
||
- takes a particular perspective</div></aside></section></section>
|
||
<section data-transition="none" class="stage-0"><section data-transition="none" class="stage-0"><DIV class="left"><H4>Coordinate</H4><UL><LI class="ghosted">arrange to take turns performing helpful tasks</LI><LI class="ghosted">via communication</LI></UL><H4>Communicate</H4><UL><LI class="ghosted">build shared understanding</LI><LI class="ghosted">of relevant knowledge</LI><LI class="ghosted">required to achieve the shared goal
|
||
<BR/>
|
||
<SPAN class="ghosted highlighted">= manage <EM>conversational state</EM></SPAN></LI></UL></DIV><aside class="notes"><P>But how do they work together?</P><P>What does it mean to cooperate?</P><P>Act of communication - contribute to shared understanding</P><P>The purpose of communication - to share state.</P><P>To replicate information from peer to peer.</P><P>Comm. that does not affect receiver's worldview
|
||
literally has no effect.</P></aside></section>
|
||
<section data-transition="none" class="stage-1"><DIV class="left"><H4>Coordinate</H4><UL><LI>arrange to take turns performing helpful tasks</LI><LI class="ghosted">via communication</LI></UL><H4>Communicate</H4><UL><LI class="ghosted">build shared understanding</LI><LI class="ghosted">of relevant knowledge</LI><LI class="ghosted">required to achieve the shared goal
|
||
<BR/>
|
||
<SPAN class="highlighted">= manage <EM>conversational state</EM></SPAN></LI></UL></DIV><aside class="notes"><P>But how do they work together?</P><P>What does it mean to cooperate?</P><P>Act of communication - contribute to shared understanding</P><P>The purpose of communication - to share state.</P><P>To replicate information from peer to peer.</P><P>Comm. that does not affect receiver's worldview
|
||
literally has no effect.</P></aside></section>
|
||
<section data-transition="none" class="stage-2"><DIV class="left"><H4>Coordinate</H4><UL><LI>arrange to take turns performing helpful tasks</LI><LI>via communication</LI></UL><H4>Communicate</H4><UL><LI class="ghosted">build shared understanding</LI><LI class="ghosted">of relevant knowledge</LI><LI class="ghosted">required to achieve the shared goal
|
||
<BR/>
|
||
<SPAN class="highlighted">= manage <EM>conversational state</EM></SPAN></LI></UL></DIV><aside class="notes"><P>But how do they work together?</P><P>What does it mean to cooperate?</P><P>Act of communication - contribute to shared understanding</P><P>The purpose of communication - to share state.</P><P>To replicate information from peer to peer.</P><P>Comm. that does not affect receiver's worldview
|
||
literally has no effect.</P></aside></section>
|
||
<section data-transition="none" class="stage-3"><DIV class="left"><H4>Coordinate</H4><UL><LI>arrange to take turns performing helpful tasks</LI><LI>via communication</LI></UL><H4>Communicate</H4><UL><LI>build shared understanding</LI><LI>of relevant knowledge</LI><LI>required to achieve the shared goal
|
||
<BR/>
|
||
<SPAN class="ghosted highlighted">= manage <EM>conversational state</EM></SPAN></LI></UL></DIV><aside class="notes"><P>But how do they work together?</P><P>What does it mean to cooperate?</P><P>Act of communication - contribute to shared understanding</P><P>The purpose of communication - to share state.</P><P>To replicate information from peer to peer.</P><P>Comm. that does not affect receiver's worldview
|
||
literally has no effect.</P></aside></section>
|
||
<section data-transition="none" class="stage-4"><DIV class="left"><H4>Coordinate</H4><UL><LI>arrange to take turns performing helpful tasks</LI><LI>via communication</LI></UL><H4>Communicate</H4><UL><LI>build shared understanding</LI><LI>of relevant knowledge</LI><LI>required to achieve the shared goal
|
||
<BR/>
|
||
<SPAN class="highlighted">= manage <EM>conversational state</EM></SPAN></LI></UL></DIV><aside class="notes"><P>But how do they work together?</P><P>What does it mean to cooperate?</P><P>Act of communication - contribute to shared understanding</P><P>The purpose of communication - to share state.</P><P>To replicate information from peer to peer.</P><P>Comm. that does not affect receiver's worldview
|
||
literally has no effect.</P></aside></section></section>
|
||
<section data-transition="none" class="stage-0"><P><img src="Figures/conversation.svg"/></P><P><SMALL>(dissertation fig. 2)</SMALL></P><aside class="notes"><UL><LI>each task shared</LI><LI>entails acts of communication</LI><LI>in the frame of an overall conversation</LI></UL><UL><LI>each act contributes to overall conv. state of shared task</LI></UL><UL><LI>when the shared task has subtasks,</LI><LI>there are often sub-conversations</LI><LI>each framed within the overall context</LI><LI>and logically dependent on the overall conversation</LI></UL></aside></section>
|
||
<section data-transition="none" class="stage-0"><TABLE class="summary-table"><TR><TD>Concurrency is about</TD><TD><EM>cooperation</EM></TD></TR><TR><TD>through</TD><TD><EM>communication</EM></TD></TR><TR><TD>of</TD><TD><EM>conversational state</EM></TD></TR></TABLE><aside class="notes"><P>So, all told, we could say that...</P></aside></section>
|
||
<section data-transition="none" class="stage-0 unpredictability"><H3>Unpredictability</H3><UL class="no-list-markers"><LI><SPAN class="check-mark">✓</SPAN> pure, total functions</LI><LI><SPAN class="cross-mark">✗</SPAN> effects</LI><LI><SPAN class="cross-mark">✗</SPAN> coroutines</LI><LI><SPAN class="cross-mark">✗</SPAN> threads & shared memory</LI><LI><SPAN class="cross-mark">✗</SPAN> network conditions</LI></UL><aside class="notes"><P>But there's a second important aspect to concurrency ...</P><P>...</P><UL><LI>Partly about programmer control.</LI><LI>The unknown is unpredictable.</LI><LI>A function cannot usually "predict" its arguments.</LI></UL></aside></section>
|
||
<section data-transition="none" class="stage-0"><TABLE class="summary-table"><TR><TD>Concurrency is about</TD><TD><EM>cooperation</EM></TD></TR><TR><TD>through</TD><TD><EM>communication</EM></TD></TR><TR><TD>of</TD><TD><EM>conversational state</EM></TD></TR><TR><TD>in an</TD><TD><EM>unpredictable</EM> setting</TD></TR></TABLE><aside class="notes"><P>... so we could expect our languages:</P><UL><LI>to make cooperation easy</LI><LI>to make communication easy and useful</LI><LI>to help synchronize perspectives on a conversation's state</LI><LI>to minimize or mitigate unpredictability, incl partial failure</LI></UL></aside></section>
|
||
<section data-transition="none" class="stage-0"><DIV class="thesisstatement"><SPAN class="language-name">Syndicate</SPAN> provides a new, effective, realizable linguistic mechanism for sharing state in a concurrent setting.</DIV><aside class="notes"><div data-markdown="">
|
||
To this end, I have developed new programming language design,
|
||
Syndicate, which rests on a new model of concurrent computation, the
|
||
dataspace model.
|
||
|
||
This brings me to my thesis statement:</div></aside></section>
|
||
<section data-transition="none" class="stage-0 thesis-expanded"><section data-transition="none" class="stage-0"><H3><SPAN><SPAN class="language-name">Syndicate</SPAN> provides a...</SPAN></H3><TABLE class="no-dividers fullwidth"><TR><TD>new</TD><TD><span class="ghosted">→</span></TD><TD><span class="ghosted">design landscape</span></TD></TR><TR><TD>effective</TD><TD><span class="ghosted">→</span></TD><TD><span class="ghosted">evaluation</span></TD></TR><TR><TD>realizable</TD><TD><span class="ghosted">→</span></TD><TD><SPAN class="ghosted">prototypes, tries</SPAN></TD></TR><TR><TD>linguistic</TD><TD><span class="ghosted">→</span></TD><TD><span class="ghosted">reified conversations</span></TD></TR><TR><TD>mechanism for sharing state</TD><TD><span class="ghosted">→</span></TD><TD><span class="ghosted">dataspace model</span></TD></TR></TABLE><P>in a concurrent setting.</P><aside class="notes"><P>not distributed - Deutsch's fallacies - control latency, scheduling</P></aside></section>
|
||
<section data-transition="none" class="stage-1"><H3><SPAN><SPAN class="language-name">Syndicate</SPAN> provides a...</SPAN></H3><TABLE class="no-dividers fullwidth"><TR><TD>new</TD><TD><span class="ghosted">→</span></TD><TD><span class="ghosted">design landscape</span></TD></TR><TR><TD>effective</TD><TD><span class="ghosted">→</span></TD><TD><span class="ghosted">evaluation</span></TD></TR><TR><TD>realizable</TD><TD><span class="ghosted">→</span></TD><TD><SPAN class="ghosted">prototypes, tries</SPAN></TD></TR><TR><TD>linguistic</TD><TD><span class="ghosted">→</span></TD><TD><span class="ghosted">reified conversations</span></TD></TR><TR><TD>mechanism for sharing state</TD><TD><span class="ghosted">→</span></TD><TD><span class="ghosted">dataspace model</span></TD></TR></TABLE><P>in a <span class="highlighted">concurrent setting.</span></P><aside class="notes"><P>not distributed - Deutsch's fallacies - control latency, scheduling</P></aside></section>
|
||
<section data-transition="none" class="stage-2"><H3><SPAN><SPAN class="language-name">Syndicate</SPAN> provides a...</SPAN></H3><TABLE class="no-dividers fullwidth"><TR><TD>new</TD><TD><span class="ghosted">→</span></TD><TD><span class="ghosted">design landscape</span></TD></TR><TR><TD>effective</TD><TD><span class="ghosted">→</span></TD><TD><span class="ghosted">evaluation</span></TD></TR><TR><TD>realizable</TD><TD><span class="ghosted">→</span></TD><TD><SPAN class="ghosted">prototypes, tries</SPAN></TD></TR><TR><TD>linguistic</TD><TD><span class="ghosted">→</span></TD><TD><span class="ghosted">reified conversations</span></TD></TR><TR class="highlighted"><TD>mechanism for sharing state</TD><TD>→</TD><TD>dataspace model</TD></TR></TABLE><P>in a concurrent setting.</P><aside class="notes"><P>The dataspace model is, at heart</P><P>a mechanism for sharing state among neighboring
|
||
concurrent components.</P><P>Focus on mechanisms for sharing state because
|
||
communication and coordination follow as special cases.</P></aside></section>
|
||
<section data-transition="none" class="stage-3"><H3><SPAN><SPAN class="language-name">Syndicate</SPAN> provides a...</SPAN></H3><TABLE class="no-dividers fullwidth"><TR><TD>new</TD><TD><span class="ghosted">→</span></TD><TD><span class="ghosted highlighted">design landscape</span></TD></TR><TR><TD>effective</TD><TD><span class="ghosted">→</span></TD><TD><span class="ghosted">evaluation</span></TD></TR><TR><TD>realizable</TD><TD><span class="ghosted">→</span></TD><TD><SPAN class="ghosted">prototypes, tries</SPAN></TD></TR><TR class="highlighted"><TD>linguistic</TD><TD>→</TD><TD>reified conversations</TD></TR><TR><TD>mechanism for sharing state</TD><TD>→</TD><TD>dataspace model</TD></TR></TABLE><P>in a concurrent setting.</P><aside class="notes"><P>DS model explains communication and coordination
|
||
among components</P><P>Does not offer assistance in structuring
|
||
internals of components.</P><P>New language constructs reifying conversations within an actor,</P><P>bridge between the language’s model and the dataspace
|
||
style of interaction</P></aside></section>
|
||
<section data-transition="none" class="stage-4"><H3><SPAN><SPAN class="language-name">Syndicate</SPAN> provides a...</SPAN></H3><TABLE class="no-dividers fullwidth"><TR><TD>new</TD><TD><span class="ghosted">→</span></TD><TD><span class="ghosted">design landscape</span></TD></TR><TR><TD>effective</TD><TD><span class="ghosted">→</span></TD><TD><span class="ghosted highlighted">evaluation</span></TD></TR><TR class="highlighted"><TD>realizable</TD><TD>→</TD><TD><SPAN>prototypes, tries</SPAN></TD></TR><TR><TD>linguistic</TD><TD>→</TD><TD>reified conversations</TD></TR><TR><TD>mechanism for sharing state</TD><TD>→</TD><TD>dataspace model</TD></TR></TABLE><P>in a concurrent setting.</P><aside class="notes"><P>I demonstrate realizability with two prototype
|
||
<SPAN class="language-name">Syndicate</SPAN> implementations (Racket, JS)</P><P>And a custom data structure based on the old idea
|
||
of a trie to allow efficient implementation</P></aside></section>
|
||
<section data-transition="none" class="stage-5"><H3><SPAN><SPAN class="language-name">Syndicate</SPAN> provides a...</SPAN></H3><TABLE class="no-dividers fullwidth"><TR><TD>new</TD><TD><span class="ghosted">→</span></TD><TD><span class="ghosted">design landscape</span></TD></TR><TR class="highlighted"><TD>effective</TD><TD>→</TD><TD>evaluation</TD></TR><TR><TD>realizable</TD><TD>→</TD><TD><SPAN>prototypes, tries</SPAN></TD></TR><TR><TD>linguistic</TD><TD>→</TD><TD>reified conversations</TD></TR><TR><TD>mechanism for sharing state</TD><TD>→</TD><TD>dataspace model</TD></TR></TABLE><P>in a concurrent setting.</P><aside class="notes"><P>Dissertation: many examples solving various programming problems</P><P>Also, have developed a handful of larger applications</P><P>Based on these, argue:</P><UL><LI><SPAN class="language-name">Syndicate</SPAN> eliminates various patterns</LI><LI>thus simplifying programming tasks</LI></UL></aside></section>
|
||
<section data-transition="none" class="stage-6"><H3><SPAN><SPAN class="language-name">Syndicate</SPAN> provides a...</SPAN></H3><TABLE class="no-dividers fullwidth"><TR class="highlighted"><TD>new</TD><TD>→</TD><TD>design landscape</TD></TR><TR><TD>effective</TD><TD>→</TD><TD>evaluation</TD></TR><TR><TD>realizable</TD><TD>→</TD><TD><SPAN>prototypes, tries</SPAN></TD></TR><TR><TD>linguistic</TD><TD>→</TD><TD>reified conversations</TD></TR><TR><TD>mechanism for sharing state</TD><TD>→</TD><TD>dataspace model</TD></TR></TABLE><P>in a concurrent setting.</P><aside class="notes"><P>Finally, it's a new idea.</P><P>Dissertation: design landscape</P><P>Talk: brief mention of the actor model and the tuplespace model</P></aside></section>
|
||
<section data-transition="none" class="stage-7"><H3><SPAN><SPAN class="language-name">Syndicate</SPAN> provides a...</SPAN></H3><TABLE class="no-dividers fullwidth"><TR><TD>new</TD><TD>→</TD><TD>design landscape</TD></TR><TR><TD>effective</TD><TD>→</TD><TD>evaluation</TD></TR><TR><TD>realizable</TD><TD>→</TD><TD><SPAN>prototypes, tries</SPAN></TD></TR><TR><TD>linguistic</TD><TD>→</TD><TD>reified conversations</TD></TR><TR><TD>mechanism for sharing state</TD><TD>→</TD><TD>dataspace model</TD></TR></TABLE><P>in a concurrent setting.</P><aside class="notes"><P>Finally, it's a new idea.</P><P>Dissertation: design landscape</P><P>Talk: brief mention of the actor model and the tuplespace model</P></aside></section>
|
||
<section data-transition="none" class="stage-8"><H3><SPAN><SPAN class="language-name">Syndicate</SPAN> provides a...</SPAN></H3><TABLE class="no-dividers fullwidth"><TR><TD>new</TD><TD>→</TD><TD>design landscape</TD></TR><TR><TD>effective</TD><TD>→</TD><TD>evaluation</TD></TR><TR><TD>realizable</TD><TD>→</TD><TD><SPAN>prototypes, <span class="highlighted">tries</span></SPAN></TD></TR><TR><TD>linguistic</TD><TD>→</TD><TD>reified conversations</TD></TR><TR><TD>mechanism for sharing state</TD><TD>→</TD><TD><span class="highlighted">dataspace model</span></TD></TR></TABLE><P>in a concurrent setting.</P><aside class="notes"><P>At the time of my proposal, ...</P><P>dataspace model + a few key properties</P><P>Racket prototype of dataspace model only</P><P>assertion-trie data structure</P></aside></section>
|
||
<section data-transition="none" class="stage-9"><H3><SPAN><SPAN class="language-name">Syndicate</SPAN> provides a...</SPAN></H3><TABLE class="no-dividers fullwidth"><TR><TD>new</TD><TD>→</TD><TD><span class="highlighted">design landscape</span></TD></TR><TR><TD>effective</TD><TD>→</TD><TD><span class="highlighted">evaluation</span></TD></TR><TR><TD>realizable</TD><TD>→</TD><TD><SPAN><span class="highlighted">prototypes,</span> tries</SPAN></TD></TR><TR><TD>linguistic</TD><TD>→</TD><TD><span class="highlighted">reified conversations</span></TD></TR><TR><TD>mechanism for sharing state</TD><TD>→</TD><TD>dataspace model</TD></TR></TABLE><P>in a concurrent setting.</P><aside class="notes"><P>Since then,</P><UL><LI>conversational language design features</LI><LI>two complete prototype implementations</LI><LI>qualitative, pattern-based evaluation</LI><LI>analysis in terms of a broader concurrency design landscape</LI></UL></aside></section>
|
||
<section data-transition="none" class="stage-10"><H3><SPAN><SPAN class="language-name">Syndicate</SPAN> provides a...</SPAN></H3><TABLE class="no-dividers fullwidth"><TR><TD>new</TD><TD>→</TD><TD>design landscape</TD></TR><TR><TD>effective</TD><TD>→</TD><TD>evaluation</TD></TR><TR><TD>realizable</TD><TD>→</TD><TD><SPAN>prototypes, tries</SPAN></TD></TR><TR><TD>linguistic</TD><TD>→</TD><TD>reified conversations</TD></TR><TR><TD>mechanism for sharing state</TD><TD>→</TD><TD>dataspace model</TD></TR></TABLE><P>in a concurrent setting.</P><aside class="notes"><P>Since then,</P><UL><LI>conversational language design features</LI><LI>two complete prototype implementations</LI><LI>qualitative, pattern-based evaluation</LI><LI>analysis in terms of a broader concurrency design landscape</LI></UL></aside></section></section>
|
||
<section data-transition="none" class="stage-0"><H3>Roadmap</H3><OL><LI>Dataspace model and assertion tries</LI><LI>Reifying conversations</LI><LI>Programming experience with <SPAN class="language-name">Syndicate</SPAN></LI><LI>Evaluation</LI><LI>Conclusion & future work</LI></OL></section>
|
||
<section data-transition="none" class="stage-0"><H3>Roadmap</H3><OL><LI class="highlighted">Dataspace model and assertion tries</LI><LI>Reifying conversations</LI><LI>Programming experience with <SPAN class="language-name">Syndicate</SPAN></LI><LI>Evaluation</LI><LI>Conclusion & future work</LI></OL></section>
|
||
<section data-transition="none" class="stage-0"><section data-transition="none" class="stage-0"><H3>Dataspace model</H3><img src="Figures/presentation-pict-0.svg"/><aside class="notes"><P><SPAN class="language-name">Syndicate</SPAN>: based on a collection of actors running in a dataspace</P><UL><LI>borrowed "actor" from actor model</LI><LI>actor analog of "dataspace": msg fabric</LI><LI>"dataspace": chosen to recall "tuplespace" from TS model</LI><LI>DS model: kind of a hybrid of actor + tuplespace models</LI></UL><P>1. each DS is an actor: recursive (dis)aggregation...</P></aside></section>
|
||
<section data-transition="none" class="stage-1"><H3>Dataspace model</H3><img src="Figures/presentation-pict-1.svg"/><aside class="notes"><P>2. ... main diff: instead of messages, actors in a
|
||
dataspace communicate by placing <EM>assertions</EM>
|
||
in their shared dataspace.</P><P>An assertion is just a record, a piece of data:
|
||
essentially, an S-expression.</P><P>Similar to the TS model: where a shared "blackboard"-style
|
||
store holds "tuples".</P></aside></section></section>
|
||
<section data-transition="none" class="stage-0"><section data-transition="none" class="stage-0"><H3><span class="green">Tuplespace model</span></H3><img src="Figures/presentation-pict-2.svg"/><P>Actions: <TT>eval</TT>,
|
||
<TT>out</TT>,
|
||
<TT>rd</TT>,
|
||
<TT>in</TT></P><P><CODE> </CODE></P><aside class="notes"><P>Tuples have independent existence</P><P>Tuples move from place to place</P><P>"lost tuple" problem</P><P>Reads are blocking operations</P><P>Extensions allow event-handlers for reacting to changes
|
||
in the tuplespace</P></aside></section>
|
||
<section data-transition="none" class="stage-1"><H3><span class="green">Tuplespace model</span></H3><img src="Figures/presentation-pict-3.svg"/><P>Actions: <TT class="highlighted">eval</TT>,
|
||
<TT>out</TT>,
|
||
<TT>rd</TT>,
|
||
<TT>in</TT></P><P><CODE> </CODE></P><aside class="notes"><P>Tuples have independent existence</P><P>Tuples move from place to place</P><P>"lost tuple" problem</P><P>Reads are blocking operations</P><P>Extensions allow event-handlers for reacting to changes
|
||
in the tuplespace</P></aside></section>
|
||
<section data-transition="none" class="stage-2"><H3><span class="green">Tuplespace model</span></H3><img src="Figures/presentation-pict-4.svg"/><P>Actions: <TT>eval</TT>,
|
||
<TT>out</TT>,
|
||
<TT>rd</TT>,
|
||
<TT>in</TT></P><P><CODE> </CODE></P><aside class="notes"><P>Tuples have independent existence</P><P>Tuples move from place to place</P><P>"lost tuple" problem</P><P>Reads are blocking operations</P><P>Extensions allow event-handlers for reacting to changes
|
||
in the tuplespace</P></aside></section>
|
||
<section data-transition="none" class="stage-3"><H3><span class="green">Tuplespace model</span></H3><img src="Figures/presentation-pict-5.svg"/><P>Actions: <TT>eval</TT>,
|
||
<TT class="highlighted">out</TT>,
|
||
<TT>rd</TT>,
|
||
<TT>in</TT></P><P><CODE>(out (balance 'account1 123.0))</CODE></P><aside class="notes"><P>Tuples have independent existence</P><P>Tuples move from place to place</P><P>"lost tuple" problem</P><P>Reads are blocking operations</P><P>Extensions allow event-handlers for reacting to changes
|
||
in the tuplespace</P></aside></section>
|
||
<section data-transition="none" class="stage-4"><H3><span class="green">Tuplespace model</span></H3><img src="Figures/presentation-pict-6.svg"/><P>Actions: <TT>eval</TT>,
|
||
<TT class="highlighted">out</TT>,
|
||
<TT>rd</TT>,
|
||
<TT>in</TT></P><P><CODE>(out (balance 'account1 123.0))</CODE></P><aside class="notes"><P>Tuples have independent existence</P><P>Tuples move from place to place</P><P>"lost tuple" problem</P><P>Reads are blocking operations</P><P>Extensions allow event-handlers for reacting to changes
|
||
in the tuplespace</P></aside></section>
|
||
<section data-transition="none" class="stage-5"><H3><span class="green">Tuplespace model</span></H3><img src="Figures/presentation-pict-7.svg"/><P>Actions: <TT>eval</TT>,
|
||
<TT>out</TT>,
|
||
<TT>rd</TT>,
|
||
<TT>in</TT></P><P><CODE> </CODE></P><aside class="notes"><P>Tuples have independent existence</P><P>Tuples move from place to place</P><P>"lost tuple" problem</P><P>Reads are blocking operations</P><P>Extensions allow event-handlers for reacting to changes
|
||
in the tuplespace</P></aside></section>
|
||
<section data-transition="none" class="stage-6"><H3><span class="green">Tuplespace model</span></H3><img src="Figures/presentation-pict-8.svg"/><P>Actions: <TT>eval</TT>,
|
||
<TT>out</TT>,
|
||
<TT class="highlighted">rd</TT>,
|
||
<TT>in</TT></P><P><CODE>(rd (balance 'account1 _))</CODE></P><aside class="notes"><P>Tuples have independent existence</P><P>Tuples move from place to place</P><P>"lost tuple" problem</P><P>Reads are blocking operations</P><P>Extensions allow event-handlers for reacting to changes
|
||
in the tuplespace</P></aside></section>
|
||
<section data-transition="none" class="stage-7"><H3><span class="green">Tuplespace model</span></H3><img src="Figures/presentation-pict-9.svg"/><P>Actions: <TT>eval</TT>,
|
||
<TT>out</TT>,
|
||
<TT>rd</TT>,
|
||
<TT>in</TT></P><P><CODE> </CODE></P><aside class="notes"><P>Tuples have independent existence</P><P>Tuples move from place to place</P><P>"lost tuple" problem</P><P>Reads are blocking operations</P><P>Extensions allow event-handlers for reacting to changes
|
||
in the tuplespace</P></aside></section>
|
||
<section data-transition="none" class="stage-8"><H3><span class="green">Tuplespace model</span></H3><img src="Figures/presentation-pict-10.svg"/><P>Actions: <TT>eval</TT>,
|
||
<TT>out</TT>,
|
||
<TT>rd</TT>,
|
||
<TT class="highlighted">in</TT></P><P><CODE>(in 'lock)</CODE></P><aside class="notes"><P>Tuples have independent existence</P><P>Tuples move from place to place</P><P>"lost tuple" problem</P><P>Reads are blocking operations</P><P>Extensions allow event-handlers for reacting to changes
|
||
in the tuplespace</P></aside></section>
|
||
<section data-transition="none" class="stage-9"><H3><span class="green">Tuplespace model</span></H3><img src="Figures/presentation-pict-11.svg"/><P>Actions: <TT>eval</TT>,
|
||
<TT>out</TT>,
|
||
<TT>rd</TT>,
|
||
<TT class="highlighted">in</TT></P><P><CODE>(in 'lock)</CODE></P><aside class="notes"><P>Tuples have independent existence</P><P>Tuples move from place to place</P><P>"lost tuple" problem</P><P>Reads are blocking operations</P><P>Extensions allow event-handlers for reacting to changes
|
||
in the tuplespace</P></aside></section>
|
||
<section data-transition="none" class="stage-10"><H3><span class="green">Tuplespace model</span></H3><img src="Figures/presentation-pict-12.svg"/><P>Actions: <TT>eval</TT>,
|
||
<TT>out</TT>,
|
||
<TT>rd</TT>,
|
||
<TT>in</TT></P><P><CODE> </CODE></P><aside class="notes"><P>Tuples have independent existence</P><P>Tuples move from place to place</P><P>"lost tuple" problem</P><P>Reads are blocking operations</P><P>Extensions allow event-handlers for reacting to changes
|
||
in the tuplespace</P></aside></section>
|
||
<section data-transition="none" class="stage-11"><H3><span class="green">Tuplespace model</span></H3><img src="Figures/presentation-pict-13.svg"/><P>Actions: <TT>eval</TT>,
|
||
<TT>out</TT>,
|
||
<TT>rd</TT>,
|
||
<TT>in</TT></P><P><CODE> </CODE></P><aside class="notes"><P>Tuples have independent existence</P><P>Tuples move from place to place</P><P>"lost tuple" problem</P><P>Reads are blocking operations</P><P>Extensions allow event-handlers for reacting to changes
|
||
in the tuplespace</P></aside></section>
|
||
<section data-transition="none" class="stage-12"><H3><span class="green">Tuplespace model</span></H3><img src="Figures/presentation-pict-14.svg"/><P>Actions: <TT>eval</TT>,
|
||
<TT>out</TT>,
|
||
<TT>rd</TT>,
|
||
<TT>in</TT></P><P><CODE> </CODE></P><aside class="notes"><P>Tuples have independent existence</P><P>Tuples move from place to place</P><P>"lost tuple" problem</P><P>Reads are blocking operations</P><P>Extensions allow event-handlers for reacting to changes
|
||
in the tuplespace</P></aside></section></section>
|
||
<section data-transition="none" class="stage-0"><section data-transition="none" class="stage-0"><H3>Dataspace model</H3><img src="Figures/presentation-pict-15.svg"/><aside class="notes"><P>By contrast, in DS model, job of DS is to keep actors
|
||
up-to-date as the contents of the dataspace changes.</P><P>In effect: a DS <EM>replicates</EM> assertions among the
|
||
actors it contains.</P></aside></section>
|
||
<section data-transition="none" class="stage-1"><H3>Dataspace model</H3><img src="Figures/presentation-pict-16.svg"/><aside class="notes"><P>Each assertion recorded with provenance:
|
||
track who asserted what</P></aside></section>
|
||
<section data-transition="none" class="stage-2"><H3>Dataspace model</H3><img src="Figures/presentation-pict-17.svg"/><aside class="notes"><P>Assertions are like Prolog assertions -
|
||
ground facts in a logic-programming system</P><P>Multiple assertions of the same value: equivalent to just one</P><P>DS replicates a set view of a bag of assertions</P><P>Crash → owned assertions removed</P><P>Compare TS "lost tuple" problem</P></aside></section>
|
||
<section data-transition="none" class="stage-3"><H3>Dataspace model</H3><img src="Figures/presentation-pict-18.svg"/><aside class="notes"><P>Assertions are like Prolog assertions -
|
||
ground facts in a logic-programming system</P><P>Multiple assertions of the same value: equivalent to just one</P><P>DS replicates a set view of a bag of assertions</P><P>Crash → owned assertions removed</P><P>Compare TS "lost tuple" problem</P></aside></section>
|
||
<section data-transition="none" class="stage-4"><H3>Dataspace model</H3><img src="Figures/presentation-pict-19.svg"/><aside class="notes"><P>Assertions are like Prolog assertions -
|
||
ground facts in a logic-programming system</P><P>Multiple assertions of the same value: equivalent to just one</P><P>DS replicates a set view of a bag of assertions</P><P>Crash → owned assertions removed</P><P>Compare TS "lost tuple" problem</P></aside></section>
|
||
<section data-transition="none" class="stage-5"><H3>Dataspace model</H3><img src="Figures/presentation-pict-20.svg"/><aside class="notes"><P>Assertions are like Prolog assertions -
|
||
ground facts in a logic-programming system</P><P>Multiple assertions of the same value: equivalent to just one</P><P>DS replicates a set view of a bag of assertions</P><P>Crash → owned assertions removed</P><P>Compare TS "lost tuple" problem</P></aside></section></section>
|
||
<section data-transition="none" class="stage-0"><section data-transition="none" class="stage-0"><P><CODE>(observe <I>P</I>)</CODE></P><P>Assertion of <EM>interest</EM> in <CODE><I>P</I></CODE></P><DIV class="ghosted"><HR/><P><CODE>(color 'boat 'blue)</CODE></P><P><SMALL>"The color of the boat is blue"</SMALL></P></DIV><DIV class="ghosted"><P><CODE>(observe (color 'boat _))</CODE></P><P><SMALL>"Interest exists in the color of the boat being anything at all"</SMALL></P></DIV><aside class="notes"><P>Tuplespace model: each subprogram uses patterns over
|
||
tuples to select items of interest.</P><P>Likewise, DS: each actor uses patterns to select assertions
|
||
of interest.</P><P>Big difference: it asserts interest in other assertions</P><P>DS uses <CODE>observe</CODE> assertions to...</P><P>Each actor gets events describing every relevant change
|
||
and only relevant changes to the dataspace.</P><P>Messages too: "short" assertions</P></aside></section>
|
||
<section data-transition="none" class="stage-1"><P><CODE>(observe <I>P</I>)</CODE></P><P>Assertion of <EM>interest</EM> in <CODE><I>P</I></CODE></P><DIV><HR/><P><CODE>(color 'boat 'blue)</CODE></P><P><SMALL>"The color of the boat is blue"</SMALL></P></DIV><DIV class="ghosted"><P><CODE>(observe (color 'boat _))</CODE></P><P><SMALL>"Interest exists in the color of the boat being anything at all"</SMALL></P></DIV><aside class="notes"><P>Tuplespace model: each subprogram uses patterns over
|
||
tuples to select items of interest.</P><P>Likewise, DS: each actor uses patterns to select assertions
|
||
of interest.</P><P>Big difference: it asserts interest in other assertions</P><P>DS uses <CODE>observe</CODE> assertions to...</P><P>Each actor gets events describing every relevant change
|
||
and only relevant changes to the dataspace.</P><P>Messages too: "short" assertions</P></aside></section>
|
||
<section data-transition="none" class="stage-2"><P><CODE>(observe <I>P</I>)</CODE></P><P>Assertion of <EM>interest</EM> in <CODE><I>P</I></CODE></P><DIV><HR/><P><CODE>(color 'boat 'blue)</CODE></P><P><SMALL>"The color of the boat is blue"</SMALL></P></DIV><DIV><P><CODE>(observe (color 'boat _))</CODE></P><P><SMALL>"Interest exists in the color of the boat being anything at all"</SMALL></P></DIV><aside class="notes"><P>Tuplespace model: each subprogram uses patterns over
|
||
tuples to select items of interest.</P><P>Likewise, DS: each actor uses patterns to select assertions
|
||
of interest.</P><P>Big difference: it asserts interest in other assertions</P><P>DS uses <CODE>observe</CODE> assertions to...</P><P>Each actor gets events describing every relevant change
|
||
and only relevant changes to the dataspace.</P><P>Messages too: "short" assertions</P></aside></section></section>
|
||
<section data-transition="none" class="stage-0"><DIV><img src="slides/ch4-stx-programs.png" style="width: 55%;"/></DIV><H3>Figure 11, chapter 4</H3><aside class="notes"><P>Dissertation: program syntax, evaluation syntax,
|
||
reduction rules</P></aside></section>
|
||
<section data-transition="none" class="stage-0"><DIV><img src="slides/ch4-stx-eval.png" style="width: 66%;"/></DIV><H3>Figure 13, chapter 4</H3></section>
|
||
<section data-transition="none" class="stage-0"><DIV><img src="slides/ch4-reductions.png" style="width: 66%;"/></DIV><H3>Figure 14, chapter 4</H3><aside class="notes"><P>Rather than go into extreme detail, I will show
|
||
enough to get the intuition and follow the
|
||
examples.</P></aside></section>
|
||
<section data-transition="none" class="stage-0"><TABLE class="summary-table"><TR><TH>Actor</TH><TD>Event transducer</TD></TR><TR><TD> </TD></TR><TR><TH>Actions</TH><TD>Spawn new actor
|
||
<BR/>
|
||
Replace assertions
|
||
<BR/>
|
||
Message</TD></TR><TR><TD> </TD></TR><TR><TH>Events</TH><TD>Dataspace has changed
|
||
<BR/>
|
||
Message</TD></TR></TABLE><aside class="notes"><P>Key things: Actors are roughly functions from an event to actions</P><P>plus a private state value they can access and update</P><P>Actions are just like the actor model, except can update its own
|
||
assertion set</P><P>Events likewise like actor model, except events describe relevant
|
||
changes to the aggregate assertion set of the dataspace</P></aside></section>
|
||
<section data-transition="none" class="stage-0"><img src="Figures/presentation-pict-21.svg"/><P>Reduction rules: deliver events;
|
||
gather actions;
|
||
interpret actions;
|
||
step contained actors</P><aside class="notes"><P>The syntax can be drawn graphically. Often I will elide the details</P><P>Every actor connects to its DS via two queues</P><P>Every DS has a queue of pending actions to interpret</P><P>It also tracks <EM>local</EM> names for actors</P><P>Names not accessible to programmer!</P><P>Finally, DS recursive: actor in a wider DS</P></aside></section>
|
||
<section data-transition="none" class="stage-0 dns-example-protocol"><section data-transition="none" class="stage-0"><P><CODE>(struct dns-entry (name address))</CODE></P><DIV class="ghosted"><HR/><P><CODE>(dns-entry "localhost" "127.0.0.1")</CODE></P><P><SMALL>"The address of <TT>localhost</TT> is <TT>127.0.0.1</TT>"</SMALL></P></DIV><DIV class="ghosted"><P><CODE>(observe (dns-entry "localhost" _))</CODE></P><P><SMALL>"Interest exists in the address of <TT>localhost</TT>"</SMALL></P></DIV><DIV class="ghosted"><P><CODE>(observe (observe (dns-entry _ _)))</CODE></P><P><SMALL>"Interest exists in <EM>interest in</EM> <TT>dns-entry</TT> records"</SMALL></P></DIV><aside class="notes"><P>Concrete example: local DNS API -- for a library</P></aside></section>
|
||
<section data-transition="none" class="stage-1"><P><CODE>(struct dns-entry (name address))</CODE></P><DIV><HR/><P><CODE>(dns-entry "localhost" "127.0.0.1")</CODE></P><P><SMALL>"The address of <TT>localhost</TT> is <TT>127.0.0.1</TT>"</SMALL></P></DIV><DIV class="ghosted"><P><CODE>(observe (dns-entry "localhost" _))</CODE></P><P><SMALL>"Interest exists in the address of <TT>localhost</TT>"</SMALL></P></DIV><DIV class="ghosted"><P><CODE>(observe (observe (dns-entry _ _)))</CODE></P><P><SMALL>"Interest exists in <EM>interest in</EM> <TT>dns-entry</TT> records"</SMALL></P></DIV><aside class="notes"><P>Concrete example: local DNS API -- for a library</P></aside></section>
|
||
<section data-transition="none" class="stage-2"><P><CODE>(struct dns-entry (name address))</CODE></P><DIV><HR/><P><CODE>(dns-entry "localhost" "127.0.0.1")</CODE></P><P><SMALL>"The address of <TT>localhost</TT> is <TT>127.0.0.1</TT>"</SMALL></P></DIV><DIV><P><CODE>(observe (dns-entry "localhost" _))</CODE></P><P><SMALL>"Interest exists in the address of <TT>localhost</TT>"</SMALL></P></DIV><DIV class="ghosted"><P><CODE>(observe (observe (dns-entry _ _)))</CODE></P><P><SMALL>"Interest exists in <EM>interest in</EM> <TT>dns-entry</TT> records"</SMALL></P></DIV><aside class="notes"><P>Concrete example: local DNS API -- for a library</P></aside></section>
|
||
<section data-transition="none" class="stage-3"><P><CODE>(struct dns-entry (name address))</CODE></P><DIV><HR/><P><CODE>(dns-entry "localhost" "127.0.0.1")</CODE></P><P><SMALL>"The address of <TT>localhost</TT> is <TT>127.0.0.1</TT>"</SMALL></P></DIV><DIV><P><CODE>(observe (dns-entry "localhost" _))</CODE></P><P><SMALL>"Interest exists in the address of <TT>localhost</TT>"</SMALL></P></DIV><DIV><P><CODE>(observe (observe (dns-entry _ _)))</CODE></P><P><SMALL>"Interest exists in <EM>interest in</EM> <TT>dns-entry</TT> records"</SMALL></P></DIV><aside class="notes"><P>Concrete example: local DNS API -- for a library</P></aside></section></section>
|
||
<section data-transition="none" class="stage-0 dns-example"><section data-transition="none" class="stage-0"><TABLE class="summary-table"><TR class="ghosted" style="background-color: rgba(255,192,192,1.0);"><TD>Client</TD><TD><UL><LI>Asserts <CODE>(observe (dns-entry "localhost" _))</CODE></LI><LI>When notified of a <CODE>(dns-entry "localhost" $addr)</CODE>, prints <CODE>addr</CODE> and quits</LI></UL></TD></TR><TR class="ghosted" style="background-color: rgba(240,255,192,1.0);"><TD>Server</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
looks up the <CODE>addr</CODE> for <CODE>name</CODE> and
|
||
asserts <CODE>(dns-entry name addr)</CODE></LI></UL></TD></TR><TR class="ghosted" style="background-color: rgba(192,192,255,1.0);"><TD>Cache</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
asserts the same, and also <CODE>(observe (laterThan ···))</CODE></LI><LI>In response to <CODE>(laterThan ···)</CODE>,
|
||
removes the corresponding assertions</LI></UL></TD></TR></TABLE><img src="Figures/presentation-pict-22.svg"/><aside class="notes"><P>Server, Cache: MULTIPLE CONCURRENT ENTRIES</P></aside></section>
|
||
<section data-transition="none" class="stage-1"><TABLE class="summary-table"><TR style="background-color: rgba(255,192,192,1.0);"><TD>Client</TD><TD><UL><LI>Asserts <CODE>(observe (dns-entry "localhost" _))</CODE></LI><LI>When notified of a <CODE>(dns-entry "localhost" $addr)</CODE>, prints <CODE>addr</CODE> and quits</LI></UL></TD></TR><TR class="ghosted" style="background-color: rgba(240,255,192,1.0);"><TD>Server</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
looks up the <CODE>addr</CODE> for <CODE>name</CODE> and
|
||
asserts <CODE>(dns-entry name addr)</CODE></LI></UL></TD></TR><TR class="ghosted" style="background-color: rgba(192,192,255,1.0);"><TD>Cache</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
asserts the same, and also <CODE>(observe (laterThan ···))</CODE></LI><LI>In response to <CODE>(laterThan ···)</CODE>,
|
||
removes the corresponding assertions</LI></UL></TD></TR></TABLE><img src="Figures/presentation-pict-23.svg"/><aside class="notes"><P>Server, Cache: MULTIPLE CONCURRENT ENTRIES</P></aside></section>
|
||
<section data-transition="none" class="stage-2"><TABLE class="summary-table"><TR style="background-color: rgba(255,192,192,1.0);"><TD>Client</TD><TD><UL><LI>Asserts <CODE>(observe (dns-entry "localhost" _))</CODE></LI><LI>When notified of a <CODE>(dns-entry "localhost" $addr)</CODE>, prints <CODE>addr</CODE> and quits</LI></UL></TD></TR><TR class="ghosted" style="background-color: rgba(240,255,192,1.0);"><TD>Server</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
looks up the <CODE>addr</CODE> for <CODE>name</CODE> and
|
||
asserts <CODE>(dns-entry name addr)</CODE></LI></UL></TD></TR><TR class="ghosted" style="background-color: rgba(192,192,255,1.0);"><TD>Cache</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
asserts the same, and also <CODE>(observe (laterThan ···))</CODE></LI><LI>In response to <CODE>(laterThan ···)</CODE>,
|
||
removes the corresponding assertions</LI></UL></TD></TR></TABLE><img src="Figures/presentation-pict-24.svg"/><aside class="notes"><P>Server, Cache: MULTIPLE CONCURRENT ENTRIES</P></aside></section>
|
||
<section data-transition="none" class="stage-3"><TABLE class="summary-table"><TR style="background-color: rgba(255,192,192,1.0);"><TD>Client</TD><TD><UL><LI>Asserts <CODE>(observe (dns-entry "localhost" _))</CODE></LI><LI>When notified of a <CODE>(dns-entry "localhost" $addr)</CODE>, prints <CODE>addr</CODE> and quits</LI></UL></TD></TR><TR class="ghosted" style="background-color: rgba(240,255,192,1.0);"><TD>Server</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
looks up the <CODE>addr</CODE> for <CODE>name</CODE> and
|
||
asserts <CODE>(dns-entry name addr)</CODE></LI></UL></TD></TR><TR class="ghosted" style="background-color: rgba(192,192,255,1.0);"><TD>Cache</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
asserts the same, and also <CODE>(observe (laterThan ···))</CODE></LI><LI>In response to <CODE>(laterThan ···)</CODE>,
|
||
removes the corresponding assertions</LI></UL></TD></TR></TABLE><img src="Figures/presentation-pict-25.svg"/><aside class="notes"><P>Server, Cache: MULTIPLE CONCURRENT ENTRIES</P></aside></section>
|
||
<section data-transition="none" class="stage-4"><TABLE class="summary-table"><TR style="background-color: rgba(255,192,192,1.0);"><TD>Client</TD><TD><UL><LI>Asserts <CODE>(observe (dns-entry "localhost" _))</CODE></LI><LI>When notified of a <CODE>(dns-entry "localhost" $addr)</CODE>, prints <CODE>addr</CODE> and quits</LI></UL></TD></TR><TR class="ghosted" style="background-color: rgba(240,255,192,1.0);"><TD>Server</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
looks up the <CODE>addr</CODE> for <CODE>name</CODE> and
|
||
asserts <CODE>(dns-entry name addr)</CODE></LI></UL></TD></TR><TR class="ghosted" style="background-color: rgba(192,192,255,1.0);"><TD>Cache</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
asserts the same, and also <CODE>(observe (laterThan ···))</CODE></LI><LI>In response to <CODE>(laterThan ···)</CODE>,
|
||
removes the corresponding assertions</LI></UL></TD></TR></TABLE><img src="Figures/presentation-pict-26.svg"/><aside class="notes"><P>Server, Cache: MULTIPLE CONCURRENT ENTRIES</P></aside></section>
|
||
<section data-transition="none" class="stage-5"><TABLE class="summary-table"><TR style="background-color: rgba(255,192,192,1.0);"><TD>Client</TD><TD><UL><LI>Asserts <CODE>(observe (dns-entry "localhost" _))</CODE></LI><LI>When notified of a <CODE>(dns-entry "localhost" $addr)</CODE>, prints <CODE>addr</CODE> and quits</LI></UL></TD></TR><TR class="ghosted" style="background-color: rgba(240,255,192,1.0);"><TD>Server</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
looks up the <CODE>addr</CODE> for <CODE>name</CODE> and
|
||
asserts <CODE>(dns-entry name addr)</CODE></LI></UL></TD></TR><TR class="ghosted" style="background-color: rgba(192,192,255,1.0);"><TD>Cache</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
asserts the same, and also <CODE>(observe (laterThan ···))</CODE></LI><LI>In response to <CODE>(laterThan ···)</CODE>,
|
||
removes the corresponding assertions</LI></UL></TD></TR></TABLE><img src="Figures/presentation-pict-27.svg"/><aside class="notes"><P>Server, Cache: MULTIPLE CONCURRENT ENTRIES</P></aside></section>
|
||
<section data-transition="none" class="stage-6"><TABLE class="summary-table"><TR style="background-color: rgba(255,192,192,1.0);"><TD>Client</TD><TD><UL><LI>Asserts <CODE>(observe (dns-entry "localhost" _))</CODE></LI><LI>When notified of a <CODE>(dns-entry "localhost" $addr)</CODE>, prints <CODE>addr</CODE> and quits</LI></UL></TD></TR><TR style="background-color: rgba(240,255,192,1.0);"><TD>Server</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
looks up the <CODE>addr</CODE> for <CODE>name</CODE> and
|
||
asserts <CODE>(dns-entry name addr)</CODE></LI></UL></TD></TR><TR class="ghosted" style="background-color: rgba(192,192,255,1.0);"><TD>Cache</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
asserts the same, and also <CODE>(observe (laterThan ···))</CODE></LI><LI>In response to <CODE>(laterThan ···)</CODE>,
|
||
removes the corresponding assertions</LI></UL></TD></TR></TABLE><img src="Figures/presentation-pict-28.svg"/><aside class="notes"><P>Server, Cache: MULTIPLE CONCURRENT ENTRIES</P></aside></section>
|
||
<section data-transition="none" class="stage-7"><TABLE class="summary-table"><TR style="background-color: rgba(255,192,192,1.0);"><TD>Client</TD><TD><UL><LI>Asserts <CODE>(observe (dns-entry "localhost" _))</CODE></LI><LI>When notified of a <CODE>(dns-entry "localhost" $addr)</CODE>, prints <CODE>addr</CODE> and quits</LI></UL></TD></TR><TR style="background-color: rgba(240,255,192,1.0);"><TD>Server</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
looks up the <CODE>addr</CODE> for <CODE>name</CODE> and
|
||
asserts <CODE>(dns-entry name addr)</CODE></LI></UL></TD></TR><TR style="background-color: rgba(192,192,255,1.0);"><TD>Cache</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
asserts the same, and also <CODE>(observe (laterThan ···))</CODE></LI><LI>In response to <CODE>(laterThan ···)</CODE>,
|
||
removes the corresponding assertions</LI></UL></TD></TR></TABLE><img src="Figures/presentation-pict-29.svg"/><aside class="notes"><P>Server, Cache: MULTIPLE CONCURRENT ENTRIES</P></aside></section>
|
||
<section data-transition="none" class="stage-8"><TABLE class="summary-table"><TR style="background-color: rgba(255,192,192,1.0);"><TD>Client</TD><TD><UL><LI>Asserts <CODE>(observe (dns-entry "localhost" _))</CODE></LI><LI>When notified of a <CODE>(dns-entry "localhost" $addr)</CODE>, prints <CODE>addr</CODE> and quits</LI></UL></TD></TR><TR style="background-color: rgba(240,255,192,1.0);"><TD>Server</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
looks up the <CODE>addr</CODE> for <CODE>name</CODE> and
|
||
asserts <CODE>(dns-entry name addr)</CODE></LI></UL></TD></TR><TR style="background-color: rgba(192,192,255,1.0);"><TD>Cache</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
asserts the same, and also <CODE>(observe (laterThan ···))</CODE></LI><LI>In response to <CODE>(laterThan ···)</CODE>,
|
||
removes the corresponding assertions</LI></UL></TD></TR></TABLE><img src="Figures/presentation-pict-30.svg"/><aside class="notes"><P>Server, Cache: MULTIPLE CONCURRENT ENTRIES</P></aside></section>
|
||
<section data-transition="none" class="stage-9"><TABLE class="summary-table"><TR style="background-color: rgba(255,192,192,1.0);"><TD>Client</TD><TD><UL><LI>Asserts <CODE>(observe (dns-entry "localhost" _))</CODE></LI><LI>When notified of a <CODE>(dns-entry "localhost" $addr)</CODE>, prints <CODE>addr</CODE> and quits</LI></UL></TD></TR><TR style="background-color: rgba(240,255,192,1.0);"><TD>Server</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
looks up the <CODE>addr</CODE> for <CODE>name</CODE> and
|
||
asserts <CODE>(dns-entry name addr)</CODE></LI></UL></TD></TR><TR style="background-color: rgba(192,192,255,1.0);"><TD>Cache</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
asserts the same, and also <CODE>(observe (laterThan ···))</CODE></LI><LI>In response to <CODE>(laterThan ···)</CODE>,
|
||
removes the corresponding assertions</LI></UL></TD></TR></TABLE><img src="Figures/presentation-pict-31.svg"/><aside class="notes"><P>Server, Cache: MULTIPLE CONCURRENT ENTRIES</P></aside></section>
|
||
<section data-transition="none" class="stage-10"><TABLE class="summary-table"><TR style="background-color: rgba(255,192,192,1.0);"><TD>Client</TD><TD><UL><LI>Asserts <CODE>(observe (dns-entry "localhost" _))</CODE></LI><LI>When notified of a <CODE>(dns-entry "localhost" $addr)</CODE>, prints <CODE>addr</CODE> and quits</LI></UL></TD></TR><TR style="background-color: rgba(240,255,192,1.0);"><TD>Server</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
looks up the <CODE>addr</CODE> for <CODE>name</CODE> and
|
||
asserts <CODE>(dns-entry name addr)</CODE></LI></UL></TD></TR><TR style="background-color: rgba(192,192,255,1.0);"><TD>Cache</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
asserts the same, and also <CODE>(observe (laterThan ···))</CODE></LI><LI>In response to <CODE>(laterThan ···)</CODE>,
|
||
removes the corresponding assertions</LI></UL></TD></TR></TABLE><img src="Figures/presentation-pict-32.svg"/><aside class="notes"><P>Server, Cache: MULTIPLE CONCURRENT ENTRIES</P></aside></section>
|
||
<section data-transition="none" class="stage-11"><TABLE class="summary-table"><TR style="background-color: rgba(255,192,192,1.0);"><TD>Client</TD><TD><UL><LI>Asserts <CODE>(observe (dns-entry "localhost" _))</CODE></LI><LI>When notified of a <CODE>(dns-entry "localhost" $addr)</CODE>, prints <CODE>addr</CODE> and quits</LI></UL></TD></TR><TR style="background-color: rgba(240,255,192,1.0);"><TD>Server</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
looks up the <CODE>addr</CODE> for <CODE>name</CODE> and
|
||
asserts <CODE>(dns-entry name addr)</CODE></LI></UL></TD></TR><TR style="background-color: rgba(192,192,255,1.0);"><TD>Cache</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
asserts the same, and also <CODE>(observe (laterThan ···))</CODE></LI><LI>In response to <CODE>(laterThan ···)</CODE>,
|
||
removes the corresponding assertions</LI></UL></TD></TR></TABLE><img src="Figures/presentation-pict-33.svg"/><aside class="notes"><P>Server, Cache: MULTIPLE CONCURRENT ENTRIES</P></aside></section>
|
||
<section data-transition="none" class="stage-12"><TABLE class="summary-table"><TR style="background-color: rgba(255,192,192,1.0);"><TD>Client</TD><TD><UL><LI>Asserts <CODE>(observe (dns-entry "localhost" _))</CODE></LI><LI>When notified of a <CODE>(dns-entry "localhost" $addr)</CODE>, prints <CODE>addr</CODE> and quits</LI></UL></TD></TR><TR style="background-color: rgba(240,255,192,1.0);"><TD>Server</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
looks up the <CODE>addr</CODE> for <CODE>name</CODE> and
|
||
asserts <CODE>(dns-entry name addr)</CODE></LI></UL></TD></TR><TR style="background-color: rgba(192,192,255,1.0);"><TD>Cache</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
asserts the same, and also <CODE>(observe (laterThan ···))</CODE></LI><LI>In response to <CODE>(laterThan ···)</CODE>,
|
||
removes the corresponding assertions</LI></UL></TD></TR></TABLE><img src="Figures/presentation-pict-34.svg"/><aside class="notes"><P>Server, Cache: MULTIPLE CONCURRENT ENTRIES</P></aside></section>
|
||
<section data-transition="none" class="stage-13"><TABLE class="summary-table"><TR style="background-color: rgba(255,192,192,1.0);"><TD>Client</TD><TD><UL><LI>Asserts <CODE>(observe (dns-entry "localhost" _))</CODE></LI><LI>When notified of a <CODE>(dns-entry "localhost" $addr)</CODE>, prints <CODE>addr</CODE> and quits</LI></UL></TD></TR><TR style="background-color: rgba(240,255,192,1.0);"><TD>Server</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
looks up the <CODE>addr</CODE> for <CODE>name</CODE> and
|
||
asserts <CODE>(dns-entry name addr)</CODE></LI></UL></TD></TR><TR style="background-color: rgba(192,192,255,1.0);"><TD>Cache</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
asserts the same, and also <CODE>(observe (laterThan ···))</CODE></LI><LI>In response to <CODE>(laterThan ···)</CODE>,
|
||
removes the corresponding assertions</LI></UL></TD></TR></TABLE><img src="Figures/presentation-pict-35.svg"/><aside class="notes"><P>Server, Cache: MULTIPLE CONCURRENT ENTRIES</P></aside></section>
|
||
<section data-transition="none" class="stage-14"><TABLE class="summary-table"><TR style="background-color: rgba(255,192,192,1.0);"><TD>Client</TD><TD><UL><LI>Asserts <CODE>(observe (dns-entry "localhost" _))</CODE></LI><LI>When notified of a <CODE>(dns-entry "localhost" $addr)</CODE>, prints <CODE>addr</CODE> and quits</LI></UL></TD></TR><TR style="background-color: rgba(240,255,192,1.0);"><TD>Server</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
looks up the <CODE>addr</CODE> for <CODE>name</CODE> and
|
||
asserts <CODE>(dns-entry name addr)</CODE></LI></UL></TD></TR><TR style="background-color: rgba(192,192,255,1.0);"><TD>Cache</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
asserts the same, and also <CODE>(observe (laterThan ···))</CODE></LI><LI>In response to <CODE>(laterThan ···)</CODE>,
|
||
removes the corresponding assertions</LI></UL></TD></TR></TABLE><img src="Figures/presentation-pict-36.svg"/><aside class="notes"><P>Server, Cache: MULTIPLE CONCURRENT ENTRIES</P></aside></section>
|
||
<section data-transition="none" class="stage-15"><TABLE class="summary-table"><TR style="background-color: rgba(255,192,192,1.0);"><TD>Client</TD><TD><UL><LI>Asserts <CODE>(observe (dns-entry "localhost" _))</CODE></LI><LI>When notified of a <CODE>(dns-entry "localhost" $addr)</CODE>, prints <CODE>addr</CODE> and quits</LI></UL></TD></TR><TR style="background-color: rgba(240,255,192,1.0);"><TD>Server</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
looks up the <CODE>addr</CODE> for <CODE>name</CODE> and
|
||
asserts <CODE>(dns-entry name addr)</CODE></LI></UL></TD></TR><TR style="background-color: rgba(192,192,255,1.0);"><TD>Cache</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
asserts the same, and also <CODE>(observe (laterThan ···))</CODE></LI><LI>In response to <CODE>(laterThan ···)</CODE>,
|
||
removes the corresponding assertions</LI></UL></TD></TR></TABLE><img src="Figures/presentation-pict-37.svg"/><aside class="notes"><P>Server, Cache: MULTIPLE CONCURRENT ENTRIES</P></aside></section>
|
||
<section data-transition="none" class="stage-16"><TABLE class="summary-table"><TR style="background-color: rgba(255,192,192,1.0);"><TD>Client</TD><TD><UL><LI>Asserts <CODE>(observe (dns-entry "localhost" _))</CODE></LI><LI>When notified of a <CODE>(dns-entry "localhost" $addr)</CODE>, prints <CODE>addr</CODE> and quits</LI></UL></TD></TR><TR style="background-color: rgba(240,255,192,1.0);"><TD>Server</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
looks up the <CODE>addr</CODE> for <CODE>name</CODE> and
|
||
asserts <CODE>(dns-entry name addr)</CODE></LI></UL></TD></TR><TR style="background-color: rgba(192,192,255,1.0);"><TD>Cache</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
asserts the same, and also <CODE>(observe (laterThan ···))</CODE></LI><LI>In response to <CODE>(laterThan ···)</CODE>,
|
||
removes the corresponding assertions</LI></UL></TD></TR></TABLE><img src="Figures/presentation-pict-38.svg"/><aside class="notes"><P>Server, Cache: MULTIPLE CONCURRENT ENTRIES</P></aside></section>
|
||
<section data-transition="none" class="stage-17"><TABLE class="summary-table"><TR style="background-color: rgba(255,192,192,1.0);"><TD>Client</TD><TD><UL><LI>Asserts <CODE>(observe (dns-entry "localhost" _))</CODE></LI><LI>When notified of a <CODE>(dns-entry "localhost" $addr)</CODE>, prints <CODE>addr</CODE> and quits</LI></UL></TD></TR><TR style="background-color: rgba(240,255,192,1.0);"><TD>Server</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
looks up the <CODE>addr</CODE> for <CODE>name</CODE> and
|
||
asserts <CODE>(dns-entry name addr)</CODE></LI></UL></TD></TR><TR style="background-color: rgba(192,192,255,1.0);"><TD>Cache</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
asserts the same, and also <CODE>(observe (laterThan ···))</CODE></LI><LI>In response to <CODE>(laterThan ···)</CODE>,
|
||
removes the corresponding assertions</LI></UL></TD></TR></TABLE><img src="Figures/presentation-pict-39.svg"/><aside class="notes"><P>Server, Cache: MULTIPLE CONCURRENT ENTRIES</P></aside></section>
|
||
<section data-transition="none" class="stage-18"><TABLE class="summary-table"><TR style="background-color: rgba(255,192,192,1.0);"><TD>Client</TD><TD><UL><LI>Asserts <CODE>(observe (dns-entry "localhost" _))</CODE></LI><LI>When notified of a <CODE>(dns-entry "localhost" $addr)</CODE>, prints <CODE>addr</CODE> and quits</LI></UL></TD></TR><TR style="background-color: rgba(240,255,192,1.0);"><TD>Server</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
looks up the <CODE>addr</CODE> for <CODE>name</CODE> and
|
||
asserts <CODE>(dns-entry name addr)</CODE></LI></UL></TD></TR><TR style="background-color: rgba(192,192,255,1.0);"><TD>Cache</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
asserts the same, and also <CODE>(observe (laterThan ···))</CODE></LI><LI>In response to <CODE>(laterThan ···)</CODE>,
|
||
removes the corresponding assertions</LI></UL></TD></TR></TABLE><img src="Figures/presentation-pict-40.svg"/><aside class="notes"><P>Server, Cache: MULTIPLE CONCURRENT ENTRIES</P></aside></section>
|
||
<section data-transition="none" class="stage-19"><TABLE class="summary-table"><TR style="background-color: rgba(255,192,192,1.0);"><TD>Client</TD><TD><UL><LI>Asserts <CODE>(observe (dns-entry "localhost" _))</CODE></LI><LI>When notified of a <CODE>(dns-entry "localhost" $addr)</CODE>, prints <CODE>addr</CODE> and quits</LI></UL></TD></TR><TR style="background-color: rgba(240,255,192,1.0);"><TD>Server</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
looks up the <CODE>addr</CODE> for <CODE>name</CODE> and
|
||
asserts <CODE>(dns-entry name addr)</CODE></LI></UL></TD></TR><TR style="background-color: rgba(192,192,255,1.0);"><TD>Cache</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
asserts the same, and also <CODE>(observe (laterThan ···))</CODE></LI><LI>In response to <CODE>(laterThan ···)</CODE>,
|
||
removes the corresponding assertions</LI></UL></TD></TR></TABLE><img src="Figures/presentation-pict-41.svg"/><aside class="notes"><P>Server, Cache: MULTIPLE CONCURRENT ENTRIES</P></aside></section>
|
||
<section data-transition="none" class="stage-20"><TABLE class="summary-table"><TR style="background-color: rgba(255,192,192,1.0);"><TD>Client</TD><TD><UL><LI>Asserts <CODE>(observe (dns-entry "localhost" _))</CODE></LI><LI>When notified of a <CODE>(dns-entry "localhost" $addr)</CODE>, prints <CODE>addr</CODE> and quits</LI></UL></TD></TR><TR style="background-color: rgba(240,255,192,1.0);"><TD>Server</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
looks up the <CODE>addr</CODE> for <CODE>name</CODE> and
|
||
asserts <CODE>(dns-entry name addr)</CODE></LI></UL></TD></TR><TR style="background-color: rgba(192,192,255,1.0);"><TD>Cache</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
asserts the same, and also <CODE>(observe (laterThan ···))</CODE></LI><LI>In response to <CODE>(laterThan ···)</CODE>,
|
||
removes the corresponding assertions</LI></UL></TD></TR></TABLE><img src="Figures/presentation-pict-42.svg"/><aside class="notes"><P>Server, Cache: MULTIPLE CONCURRENT ENTRIES</P></aside></section>
|
||
<section data-transition="none" class="stage-21"><TABLE class="summary-table"><TR style="background-color: rgba(255,192,192,1.0);"><TD>Client</TD><TD><UL><LI>Asserts <CODE>(observe (dns-entry "localhost" _))</CODE></LI><LI>When notified of a <CODE>(dns-entry "localhost" $addr)</CODE>, prints <CODE>addr</CODE> and quits</LI></UL></TD></TR><TR style="background-color: rgba(240,255,192,1.0);"><TD>Server</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
looks up the <CODE>addr</CODE> for <CODE>name</CODE> and
|
||
asserts <CODE>(dns-entry name addr)</CODE></LI></UL></TD></TR><TR style="background-color: rgba(192,192,255,1.0);"><TD>Cache</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
asserts the same, and also <CODE>(observe (laterThan ···))</CODE></LI><LI>In response to <CODE>(laterThan ···)</CODE>,
|
||
removes the corresponding assertions</LI></UL></TD></TR></TABLE><img src="Figures/presentation-pict-43.svg"/><aside class="notes"><P>Server, Cache: MULTIPLE CONCURRENT ENTRIES</P></aside></section>
|
||
<section data-transition="none" class="stage-22"><TABLE class="summary-table"><TR style="background-color: rgba(255,192,192,1.0);"><TD>Client</TD><TD><UL><LI>Asserts <CODE>(observe (dns-entry "localhost" _))</CODE></LI><LI>When notified of a <CODE>(dns-entry "localhost" $addr)</CODE>, prints <CODE>addr</CODE> and quits</LI></UL></TD></TR><TR style="background-color: rgba(240,255,192,1.0);"><TD>Server</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
looks up the <CODE>addr</CODE> for <CODE>name</CODE> and
|
||
asserts <CODE>(dns-entry name addr)</CODE></LI></UL></TD></TR><TR style="background-color: rgba(192,192,255,1.0);"><TD>Cache</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
asserts the same, and also <CODE>(observe (laterThan ···))</CODE></LI><LI>In response to <CODE>(laterThan ···)</CODE>,
|
||
removes the corresponding assertions</LI></UL></TD></TR></TABLE><img src="Figures/presentation-pict-44.svg"/><aside class="notes"><P>Server, Cache: MULTIPLE CONCURRENT ENTRIES</P></aside></section>
|
||
<section data-transition="none" class="stage-23"><TABLE class="summary-table"><TR style="background-color: rgba(255,192,192,1.0);"><TD>Client</TD><TD><UL><LI>Asserts <CODE>(observe (dns-entry "localhost" _))</CODE></LI><LI>When notified of a <CODE>(dns-entry "localhost" $addr)</CODE>, prints <CODE>addr</CODE> and quits</LI></UL></TD></TR><TR style="background-color: rgba(240,255,192,1.0);"><TD>Server</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
looks up the <CODE>addr</CODE> for <CODE>name</CODE> and
|
||
asserts <CODE>(dns-entry name addr)</CODE></LI></UL></TD></TR><TR style="background-color: rgba(192,192,255,1.0);"><TD>Cache</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
asserts the same, and also <CODE>(observe (laterThan ···))</CODE></LI><LI>In response to <CODE>(laterThan ···)</CODE>,
|
||
removes the corresponding assertions</LI></UL></TD></TR></TABLE><img src="Figures/presentation-pict-45.svg"/><aside class="notes"><P>Server, Cache: MULTIPLE CONCURRENT ENTRIES</P></aside></section>
|
||
<section data-transition="none" class="stage-24"><TABLE class="summary-table"><TR style="background-color: rgba(255,192,192,1.0);"><TD>Client</TD><TD><UL><LI>Asserts <CODE>(observe (dns-entry "localhost" _))</CODE></LI><LI>When notified of a <CODE>(dns-entry "localhost" $addr)</CODE>, prints <CODE>addr</CODE> and quits</LI></UL></TD></TR><TR style="background-color: rgba(240,255,192,1.0);"><TD>Server</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
looks up the <CODE>addr</CODE> for <CODE>name</CODE> and
|
||
asserts <CODE>(dns-entry name addr)</CODE></LI></UL></TD></TR><TR style="background-color: rgba(192,192,255,1.0);"><TD>Cache</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
asserts the same, and also <CODE>(observe (laterThan ···))</CODE></LI><LI>In response to <CODE>(laterThan ···)</CODE>,
|
||
removes the corresponding assertions</LI></UL></TD></TR></TABLE><img src="Figures/presentation-pict-46.svg"/><aside class="notes"><P>Server, Cache: MULTIPLE CONCURRENT ENTRIES</P></aside></section>
|
||
<section data-transition="none" class="stage-25"><TABLE class="summary-table"><TR style="background-color: rgba(255,192,192,1.0);"><TD>Client</TD><TD><UL><LI>Asserts <CODE>(observe (dns-entry "localhost" _))</CODE></LI><LI>When notified of a <CODE>(dns-entry "localhost" $addr)</CODE>, prints <CODE>addr</CODE> and quits</LI></UL></TD></TR><TR style="background-color: rgba(240,255,192,1.0);"><TD>Server</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
looks up the <CODE>addr</CODE> for <CODE>name</CODE> and
|
||
asserts <CODE>(dns-entry name addr)</CODE></LI></UL></TD></TR><TR style="background-color: rgba(192,192,255,1.0);"><TD>Cache</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
asserts the same, and also <CODE>(observe (laterThan ···))</CODE></LI><LI>In response to <CODE>(laterThan ···)</CODE>,
|
||
removes the corresponding assertions</LI></UL></TD></TR></TABLE><img src="Figures/presentation-pict-47.svg"/><aside class="notes"><P>Server, Cache: MULTIPLE CONCURRENT ENTRIES</P></aside></section>
|
||
<section data-transition="none" class="stage-26"><TABLE class="summary-table"><TR style="background-color: rgba(255,192,192,1.0);"><TD>Client</TD><TD><UL><LI>Asserts <CODE>(observe (dns-entry "localhost" _))</CODE></LI><LI>When notified of a <CODE>(dns-entry "localhost" $addr)</CODE>, prints <CODE>addr</CODE> and quits</LI></UL></TD></TR><TR style="background-color: rgba(240,255,192,1.0);"><TD>Server</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
looks up the <CODE>addr</CODE> for <CODE>name</CODE> and
|
||
asserts <CODE>(dns-entry name addr)</CODE></LI></UL></TD></TR><TR style="background-color: rgba(192,192,255,1.0);"><TD>Cache</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
asserts the same, and also <CODE>(observe (laterThan ···))</CODE></LI><LI>In response to <CODE>(laterThan ···)</CODE>,
|
||
removes the corresponding assertions</LI></UL></TD></TR></TABLE><img src="Figures/presentation-pict-48.svg"/><aside class="notes"><P>Server, Cache: MULTIPLE CONCURRENT ENTRIES</P></aside></section></section>
|
||
<section data-transition="none" class="stage-0"><section data-transition="none" class="stage-0"><DIV class="switch-container" style="height: 8em;"><img src="Figures/presentation-pict-49.svg"/></DIV><DIV class="ghosted"><img src="Figures/presentation-pict-50.svg"/></DIV><aside class="notes"><P>Reads a nested structure left-to-right as a sequence of tokens</P><P>Takes care to share structure</P></aside></section>
|
||
<section data-transition="none" class="stage-1"><DIV class="switch-container" style="height: 8em;"><img src="Figures/presentation-pict-51.svg"/></DIV><DIV><img src="Figures/presentation-pict-52.svg"/></DIV><aside class="notes"><P>Reads a nested structure left-to-right as a sequence of tokens</P><P>Takes care to share structure</P></aside></section>
|
||
<section data-transition="none" class="stage-2"><DIV class="switch-container" style="height: 8em;"><UL class="no-list-markers"><LI>Supports S-expression-like data <EM>and wildcards</EM> well</LI><LI>Closed under ∪, ∩, −</LI><LI>Reasonably efficient ∪, ∩, −</LI><LI>Reasonably compact</LI><LI>Gives efficient routing of assertions and messages</LI></UL></DIV><DIV><img src="Figures/presentation-pict-54.svg"/></DIV><aside class="notes"><P>Reads a nested structure left-to-right as a sequence of tokens</P><P>Takes care to share structure</P></aside></section></section>
|
||
<section data-transition="none" class="stage-0"><H3>Properties</H3></section>
|
||
<section data-transition="none" class="stage-0"><section data-transition="none" class="stage-0"><UL class="no-list-markers"><LI><SPAN class="check-mark">✓</SPAN> No errors and stuck-free</LI><LI><SPAN class="check-mark">✓</SPAN> Deterministic</LI><LI><SPAN class="check-mark">✓</SPAN> Order-preserving</LI><LI class="ghosted"><SPAN class="check-mark">✓</SPAN> Conversational "soundness", "completeness"</LI></UL><UL class="ghosted"><LI>actions correctly interpreted</LI><LI>an event for every relevant change</LI><LI>every event is
|
||
<UL><LI><EM>truthful</EM>,</LI><LI><EM>relevant</EM>, and</LI><LI><EM>complete</EM>.</LI></UL></LI></UL><aside class="notes"><P>The dataspace is network-like: you don't want your network
|
||
to crash or "signal an exception"</P><P>Determinism: mostly to show a whole DS can be viewed
|
||
as an event-transducing function</P><P>Can relax determinism with simple changes to the reduction rules</P><P>Order-preserving: programmer relies on this</P><P>NEW: conversational soundness/completeness</P></aside></section>
|
||
<section data-transition="none" class="stage-1"><UL class="no-list-markers"><LI><SPAN class="check-mark">✓</SPAN> No errors and stuck-free</LI><LI><SPAN class="check-mark">✓</SPAN> Deterministic</LI><LI><SPAN class="check-mark">✓</SPAN> Order-preserving</LI><LI><SPAN class="check-mark">✓</SPAN> Conversational "soundness", "completeness"</LI></UL><UL class="ghosted"><LI>actions correctly interpreted</LI><LI>an event for every relevant change</LI><LI>every event is
|
||
<UL><LI><EM>truthful</EM>,</LI><LI><EM>relevant</EM>, and</LI><LI><EM>complete</EM>.</LI></UL></LI></UL><aside class="notes"><P>The dataspace is network-like: you don't want your network
|
||
to crash or "signal an exception"</P><P>Determinism: mostly to show a whole DS can be viewed
|
||
as an event-transducing function</P><P>Can relax determinism with simple changes to the reduction rules</P><P>Order-preserving: programmer relies on this</P><P>NEW: conversational soundness/completeness</P></aside></section>
|
||
<section data-transition="none" class="stage-2"><UL class="no-list-markers"><LI class="greyout"><SPAN class="check-mark">✓</SPAN> No errors and stuck-free</LI><LI class="greyout"><SPAN class="check-mark">✓</SPAN> Deterministic</LI><LI class="greyout"><SPAN class="check-mark">✓</SPAN> Order-preserving</LI><LI><SPAN class="check-mark">✓</SPAN> Conversational "soundness", "completeness"</LI></UL><UL><LI>actions correctly interpreted</LI><LI>an event for every relevant change</LI><LI>every event is
|
||
<UL><LI><EM>truthful</EM>,</LI><LI><EM>relevant</EM>, and</LI><LI><EM>complete</EM>.</LI></UL></LI></UL><aside class="notes"><P>The dataspace is network-like: you don't want your network
|
||
to crash or "signal an exception"</P><P>Determinism: mostly to show a whole DS can be viewed
|
||
as an event-transducing function</P><P>Can relax determinism with simple changes to the reduction rules</P><P>Order-preserving: programmer relies on this</P><P>NEW: conversational soundness/completeness</P></aside></section></section>
|
||
<section data-transition="none" class="stage-0 scrollable"><DIV><img src="slides/simple-dns-trace.svg"/></DIV><aside class="notes"><P>NEW: event trace</P><P>Programming model, mental model - line up with reduction semantics</P><P>So does the implementation</P><P>Capture log entries = reduction steps = useful information for programmer</P><P>Quite a direct rendering of a trace, generated by the implementation</P></aside></section>
|
||
<section data-transition="none" class="stage-0"><H3>Roadmap</H3><OL><LI>Dataspace model and assertion tries</LI><LI class="highlighted">Reifying conversations</LI><LI>Programming experience with <SPAN class="language-name">Syndicate</SPAN></LI><LI>Evaluation</LI><LI>Conclusion & future work</LI></OL><aside class="notes"><P>DS model lets us communicate changes in
|
||
conversational state</P><P>Awesome!</P><P>However, most actors engage in multiple
|
||
conversations simultaneously.</P></aside></section>
|
||
<section data-transition="none" class="stage-0 conversation-animation"><svg id="conversation-animation" width="960" height="700"></svg><aside class="notes"><P>Consider the DNS cache actor.</P><P>When there's something to cache, it communicates with
|
||
both the "server" and "timer" actors for that item.</P><P>And there will be multiple items active at once.</P><P>Keeping track of which assertions relate to which of
|
||
an actor's tasks and responsibilities is difficult,
|
||
error prone, ripe for automation.</P><P>We need support in the languages we use to write
|
||
leaf actors to help us interpret the events we
|
||
receive and produce appropriate actions corresponding
|
||
to the actor's changes in internal state.</P></aside></section>
|
||
<section data-transition="none" class="stage-0"><H3>Facet</H3><UL><LI>Assertions</LI><LI>Local fields</LI><LI>Data flow → control flow</LI><LI>Control flow → data flow</LI><LI>Local data → shared data</LI><LI>Shared data → local data</LI><LI>Subfacets</LI></UL><aside class="notes"><P>In response to this need, I've introduced a new concept
|
||
called a <EM>facet</EM>.</P><P>Scopes state/behavior for partic. conv. within an actor</P><P>Roughly: everything an actor needs to know and do
|
||
within a partic. conv. frame</P><UL><LI>public aspect</LI><LI>private aspect</LI><LI>...</LI></UL></aside></section>
|
||
<section data-transition="none" class="stage-0"><section data-transition="none" class="stage-0"><DIV class="bigger"><pre><code class="scheme">(react <SPAN>(field [<EM>field-name</EM> <EM>expr</EM>] ...)</SPAN>
|
||
<EM>endpoint-expr</EM> ...)
|
||
|
||
<EM>endpoint-expr</EM>
|
||
= <SPAN>(assert <EM>expr</EM>)</SPAN>
|
||
<SPAN> | (on (asserted <EM>pattern</EM>) <EM>expr</EM> ...)
|
||
| (on (retracted <EM>pattern</EM>) <EM>expr</EM> ...)
|
||
| (on (message <EM>pattern</EM>) <EM>expr</EM> ...)</SPAN>
|
||
<SPAN> | (on-start <EM>expr</EM> ...)
|
||
| (on-stop <EM>expr</EM> ...)</SPAN></code></pre><pre class="ghosted"><code class="scheme"><SPAN>(stop-when <EM>E</EM> <EM>expr</EM> ...)
|
||
= (on <EM>E</EM> (stop-facet (current-facet-id) <EM>expr</EM> ...))</SPAN>
|
||
|
||
<SPAN>(during <EM>pattern</EM> <EM>endpoint-expr</EM> ...)
|
||
= (on (asserted <EM>pattern</EM>)
|
||
(react (stop-when (retracted <EM>pattern′</EM>))
|
||
<EM>endpoint-expr</EM> ...))</SPAN></code></pre></DIV></section>
|
||
<section data-transition="none" class="stage-1"><DIV class="bigger"><pre><code class="scheme">(react <MARK>(field [<EM>field-name</EM> <EM>expr</EM>] ...)</MARK>
|
||
<EM>endpoint-expr</EM> ...)
|
||
|
||
<EM>endpoint-expr</EM>
|
||
= <SPAN>(assert <EM>expr</EM>)</SPAN>
|
||
<SPAN> | (on (asserted <EM>pattern</EM>) <EM>expr</EM> ...)
|
||
| (on (retracted <EM>pattern</EM>) <EM>expr</EM> ...)
|
||
| (on (message <EM>pattern</EM>) <EM>expr</EM> ...)</SPAN>
|
||
<SPAN> | (on-start <EM>expr</EM> ...)
|
||
| (on-stop <EM>expr</EM> ...)</SPAN></code></pre><pre class="ghosted"><code class="scheme"><MARK>(stop-when <EM>E</EM> <EM>expr</EM> ...)
|
||
= (on <EM>E</EM> (stop-facet (current-facet-id) <EM>expr</EM> ...))</MARK>
|
||
|
||
<SPAN>(during <EM>pattern</EM> <EM>endpoint-expr</EM> ...)
|
||
= (on (asserted <EM>pattern</EM>)
|
||
(react (stop-when (retracted <EM>pattern′</EM>))
|
||
<EM>endpoint-expr</EM> ...))</SPAN></code></pre></DIV></section>
|
||
<section data-transition="none" class="stage-2"><DIV class="bigger"><pre><code class="scheme">(react <SPAN>(field [<EM>field-name</EM> <EM>expr</EM>] ...)</SPAN>
|
||
<EM>endpoint-expr</EM> ...)
|
||
|
||
<EM>endpoint-expr</EM>
|
||
= <MARK>(assert <EM>expr</EM>)</MARK>
|
||
<SPAN> | (on (asserted <EM>pattern</EM>) <EM>expr</EM> ...)
|
||
| (on (retracted <EM>pattern</EM>) <EM>expr</EM> ...)
|
||
| (on (message <EM>pattern</EM>) <EM>expr</EM> ...)</SPAN>
|
||
<SPAN> | (on-start <EM>expr</EM> ...)
|
||
| (on-stop <EM>expr</EM> ...)</SPAN></code></pre><pre class="ghosted"><code class="scheme"><SPAN>(stop-when <EM>E</EM> <EM>expr</EM> ...)
|
||
= (on <EM>E</EM> (stop-facet (current-facet-id) <EM>expr</EM> ...))</SPAN>
|
||
|
||
<MARK>(during <EM>pattern</EM> <EM>endpoint-expr</EM> ...)
|
||
= (on (asserted <EM>pattern</EM>)
|
||
(react (stop-when (retracted <EM>pattern′</EM>))
|
||
<EM>endpoint-expr</EM> ...))</MARK></code></pre></DIV></section>
|
||
<section data-transition="none" class="stage-3"><DIV class="bigger"><pre><code class="scheme">(react <SPAN>(field [<EM>field-name</EM> <EM>expr</EM>] ...)</SPAN>
|
||
<EM>endpoint-expr</EM> ...)
|
||
|
||
<EM>endpoint-expr</EM>
|
||
= <SPAN>(assert <EM>expr</EM>)</SPAN>
|
||
<MARK> | (on (asserted <EM>pattern</EM>) <EM>expr</EM> ...)
|
||
| (on (retracted <EM>pattern</EM>) <EM>expr</EM> ...)
|
||
| (on (message <EM>pattern</EM>) <EM>expr</EM> ...)</MARK>
|
||
<SPAN> | (on-start <EM>expr</EM> ...)
|
||
| (on-stop <EM>expr</EM> ...)</SPAN></code></pre><pre class="ghosted"><code class="scheme"><SPAN>(stop-when <EM>E</EM> <EM>expr</EM> ...)
|
||
= (on <EM>E</EM> (stop-facet (current-facet-id) <EM>expr</EM> ...))</SPAN>
|
||
|
||
<SPAN>(during <EM>pattern</EM> <EM>endpoint-expr</EM> ...)
|
||
= (on (asserted <EM>pattern</EM>)
|
||
(react (stop-when (retracted <EM>pattern′</EM>))
|
||
<EM>endpoint-expr</EM> ...))</SPAN></code></pre></DIV></section>
|
||
<section data-transition="none" class="stage-4"><DIV class="bigger"><pre><code class="scheme">(react <SPAN>(field [<EM>field-name</EM> <EM>expr</EM>] ...)</SPAN>
|
||
<EM>endpoint-expr</EM> ...)
|
||
|
||
<EM>endpoint-expr</EM>
|
||
= <SPAN>(assert <EM>expr</EM>)</SPAN>
|
||
<SPAN> | (on (asserted <EM>pattern</EM>) <EM>expr</EM> ...)
|
||
| (on (retracted <EM>pattern</EM>) <EM>expr</EM> ...)
|
||
| (on (message <EM>pattern</EM>) <EM>expr</EM> ...)</SPAN>
|
||
<MARK> | (on-start <EM>expr</EM> ...)
|
||
| (on-stop <EM>expr</EM> ...)</MARK></code></pre><pre class="ghosted"><code class="scheme"><SPAN>(stop-when <EM>E</EM> <EM>expr</EM> ...)
|
||
= (on <EM>E</EM> (stop-facet (current-facet-id) <EM>expr</EM> ...))</SPAN>
|
||
|
||
<SPAN>(during <EM>pattern</EM> <EM>endpoint-expr</EM> ...)
|
||
= (on (asserted <EM>pattern</EM>)
|
||
(react (stop-when (retracted <EM>pattern′</EM>))
|
||
<EM>endpoint-expr</EM> ...))</SPAN></code></pre></DIV></section>
|
||
<section data-transition="none" class="stage-5"><DIV class="bigger"><pre><code class="scheme">(react <SPAN>(field [<EM>field-name</EM> <EM>expr</EM>] ...)</SPAN>
|
||
<EM>endpoint-expr</EM> ...)
|
||
|
||
<EM>endpoint-expr</EM>
|
||
= <SPAN>(assert <EM>expr</EM>)</SPAN>
|
||
<SPAN> | (on (asserted <EM>pattern</EM>) <EM>expr</EM> ...)
|
||
| (on (retracted <EM>pattern</EM>) <EM>expr</EM> ...)
|
||
| (on (message <EM>pattern</EM>) <EM>expr</EM> ...)</SPAN>
|
||
<SPAN> | (on-start <EM>expr</EM> ...)
|
||
| (on-stop <EM>expr</EM> ...)</SPAN></code></pre><pre class="ghosted"><code class="scheme"><SPAN>(stop-when <EM>E</EM> <EM>expr</EM> ...)
|
||
= (on <EM>E</EM> (stop-facet (current-facet-id) <EM>expr</EM> ...))</SPAN>
|
||
|
||
<SPAN>(during <EM>pattern</EM> <EM>endpoint-expr</EM> ...)
|
||
= (on (asserted <EM>pattern</EM>)
|
||
(react (stop-when (retracted <EM>pattern′</EM>))
|
||
<EM>endpoint-expr</EM> ...))</SPAN></code></pre></DIV></section>
|
||
<section data-transition="none" class="stage-6"><DIV class="bigger"><pre><code class="scheme">(react <SPAN>(field [<EM>field-name</EM> <EM>expr</EM>] ...)</SPAN>
|
||
<EM>endpoint-expr</EM> ...)
|
||
|
||
<EM>endpoint-expr</EM>
|
||
= <SPAN>(assert <EM>expr</EM>)</SPAN>
|
||
<SPAN> | (on (asserted <EM>pattern</EM>) <EM>expr</EM> ...)
|
||
| (on (retracted <EM>pattern</EM>) <EM>expr</EM> ...)
|
||
| (on (message <EM>pattern</EM>) <EM>expr</EM> ...)</SPAN>
|
||
<SPAN> | (on-start <EM>expr</EM> ...)
|
||
| (on-stop <EM>expr</EM> ...)</SPAN></code></pre><pre><code class="scheme"><SPAN>(stop-when <EM>E</EM> <EM>expr</EM> ...)
|
||
= (on <EM>E</EM> (stop-facet (current-facet-id) <EM>expr</EM> ...))</SPAN>
|
||
|
||
<SPAN>(during <EM>pattern</EM> <EM>endpoint-expr</EM> ...)
|
||
= (on (asserted <EM>pattern</EM>)
|
||
(react (stop-when (retracted <EM>pattern′</EM>))
|
||
<EM>endpoint-expr</EM> ...))</SPAN></code></pre></DIV></section>
|
||
<section data-transition="none" class="stage-7"><DIV class="bigger"><pre><code class="scheme">(react <SPAN>(field [<EM>field-name</EM> <EM>expr</EM>] ...)</SPAN>
|
||
<EM>endpoint-expr</EM> ...)
|
||
|
||
<EM>endpoint-expr</EM>
|
||
= <SPAN>(assert <EM>expr</EM>)</SPAN>
|
||
<SPAN> | (on (asserted <EM>pattern</EM>) <EM>expr</EM> ...)
|
||
| (on (retracted <EM>pattern</EM>) <EM>expr</EM> ...)
|
||
| (on (message <EM>pattern</EM>) <EM>expr</EM> ...)</SPAN>
|
||
<SPAN> | (on-start <EM>expr</EM> ...)
|
||
| (on-stop <EM>expr</EM> ...)</SPAN></code></pre><pre><code class="scheme"><MARK>(stop-when <EM>E</EM> <EM>expr</EM> ...)
|
||
= (on <EM>E</EM> (stop-facet (current-facet-id) <EM>expr</EM> ...))</MARK>
|
||
|
||
<SPAN>(during <EM>pattern</EM> <EM>endpoint-expr</EM> ...)
|
||
= (on (asserted <EM>pattern</EM>)
|
||
(react (stop-when (retracted <EM>pattern′</EM>))
|
||
<EM>endpoint-expr</EM> ...))</SPAN></code></pre></DIV></section>
|
||
<section data-transition="none" class="stage-8"><DIV class="bigger"><pre><code class="scheme">(react <SPAN>(field [<EM>field-name</EM> <EM>expr</EM>] ...)</SPAN>
|
||
<EM>endpoint-expr</EM> ...)
|
||
|
||
<EM>endpoint-expr</EM>
|
||
= <SPAN>(assert <EM>expr</EM>)</SPAN>
|
||
<SPAN> | (on (asserted <EM>pattern</EM>) <EM>expr</EM> ...)
|
||
| (on (retracted <EM>pattern</EM>) <EM>expr</EM> ...)
|
||
| (on (message <EM>pattern</EM>) <EM>expr</EM> ...)</SPAN>
|
||
<SPAN> | (on-start <EM>expr</EM> ...)
|
||
| (on-stop <EM>expr</EM> ...)</SPAN></code></pre><pre><code class="scheme"><SPAN>(stop-when <EM>E</EM> <EM>expr</EM> ...)
|
||
= (on <EM>E</EM> (stop-facet (current-facet-id) <EM>expr</EM> ...))</SPAN>
|
||
|
||
<MARK>(during <EM>pattern</EM> <EM>endpoint-expr</EM> ...)
|
||
= (on (asserted <EM>pattern</EM>)
|
||
(react (stop-when (retracted <EM>pattern′</EM>))
|
||
<EM>endpoint-expr</EM> ...))</MARK></code></pre></DIV></section>
|
||
<section data-transition="none" class="stage-9"><DIV class="bigger"><pre><code class="scheme">(react <SPAN>(field [<EM>field-name</EM> <EM>expr</EM>] ...)</SPAN>
|
||
<EM>endpoint-expr</EM> ...)
|
||
|
||
<EM>endpoint-expr</EM>
|
||
= <SPAN>(assert <EM>expr</EM>)</SPAN>
|
||
<SPAN> | (on (asserted <EM>pattern</EM>) <EM>expr</EM> ...)
|
||
| (on (retracted <EM>pattern</EM>) <EM>expr</EM> ...)
|
||
| (on (message <EM>pattern</EM>) <EM>expr</EM> ...)</SPAN>
|
||
<SPAN> | (on-start <EM>expr</EM> ...)
|
||
| (on-stop <EM>expr</EM> ...)</SPAN></code></pre><pre><code class="scheme"><SPAN>(stop-when <EM>E</EM> <EM>expr</EM> ...)
|
||
= (on <EM>E</EM> (stop-facet (current-facet-id) <EM>expr</EM> ...))</SPAN>
|
||
|
||
<SPAN>(during <EM>pattern</EM> <EM>endpoint-expr</EM> ...)
|
||
= (on (asserted <EM>pattern</EM>)
|
||
(react (stop-when (retracted <EM>pattern′</EM>))
|
||
<EM>endpoint-expr</EM> ...))</SPAN></code></pre></DIV></section></section>
|
||
<section data-transition="none" class="stage-0 dns-example"><section data-transition="none" class="stage-0"><TABLE class="summary-table"><TR style="background-color: rgba(255,192,192,1.0);"><TD>Client</TD><TD><UL><LI>Asserts <CODE>(observe (dns-entry "localhost" _))</CODE></LI><LI>When notified of a <CODE>(dns-entry "localhost" $addr)</CODE>, prints <CODE>addr</CODE> and quits</LI></UL></TD></TR><TR class="ghosted"><TD colspan="2"><pre style="background-color: rgba(255,192,192,1.0);"><code class="scheme">(spawn <SPAN>(stop-when <SPAN>(asserted (dns-entry "localhost" $addr))</SPAN></SPAN>
|
||
<SPAN>(printf "localhost is ~a\n" addr))</SPAN>)</code></pre></TD></TR><TR style="background-color: rgba(240,255,192,1.0);"><TD>Server</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
looks up the <CODE>addr</CODE> for <CODE>name</CODE> and
|
||
asserts <CODE>(dns-entry name addr)</CODE></LI></UL></TD></TR><TR class="ghosted"><TD colspan="2"><pre style="background-color: rgba(240,255,192,1.0);"><code class="scheme">(spawn (<MARK>on</MARK> (<MARK>asserted</MARK> (observe (dns-entry $name _)))
|
||
(<MARK>react</MARK> (<MARK>stop-when</MARK> (<MARK>retracted</MARK> (observe (dns-entry ···))))
|
||
(assert (dns-entry "localhost" ···)))))</code></pre></TD></TR><TR style="background-color: rgba(192,192,255,1.0);"><TD>Cache</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
asserts the same, and also <CODE>(observe (laterThan ···))</CODE></LI><LI>In response to <CODE>(laterThan ···)</CODE>,
|
||
removes the corresponding assertions</LI></UL></TD></TR><TR class="ghosted"><TD colspan="2"><pre style="background-color: rgba(192,192,255,1.0);"><code class="scheme">(spawn (on (asserted <SPAN>(observe (dns-entry $name _))</SPAN>)
|
||
<SPAN>(define deadline (+ (current-inexact-milliseconds) 2000))</SPAN>
|
||
(react <SPAN>(stop-when (asserted (later-than deadline)))</SPAN>
|
||
<SPAN>(assert (observe (dns-entry name _)))</SPAN>)))</code></pre></TD></TR></TABLE></section>
|
||
<section data-transition="none" class="stage-1"><TABLE class="summary-table"><TR style="background-color: rgba(255,192,192,1.0);"><TD>Client</TD><TD><UL><LI>Asserts <CODE>(observe (dns-entry "localhost" _))</CODE></LI><LI>When notified of a <CODE>(dns-entry "localhost" $addr)</CODE>, prints <CODE>addr</CODE> and quits</LI></UL></TD></TR><TR><TD colspan="2"><pre style="background-color: rgba(255,192,192,1.0);"><code class="scheme">(spawn <SPAN>(stop-when <SPAN>(asserted (dns-entry "localhost" $addr))</SPAN></SPAN>
|
||
<SPAN>(printf "localhost is ~a\n" addr))</SPAN>)</code></pre></TD></TR><TR style="background-color: rgba(240,255,192,1.0);"><TD>Server</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
looks up the <CODE>addr</CODE> for <CODE>name</CODE> and
|
||
asserts <CODE>(dns-entry name addr)</CODE></LI></UL></TD></TR><TR class="ghosted"><TD colspan="2"><pre style="background-color: rgba(240,255,192,1.0);"><code class="scheme">(spawn (during (observe (dns-entry $name _))
|
||
(define addr (engage-in-internet-dns-protocol-for name))
|
||
(assert (dns-entry name addr))))</code></pre></TD></TR><TR style="background-color: rgba(192,192,255,1.0);"><TD>Cache</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
asserts the same, and also <CODE>(observe (laterThan ···))</CODE></LI><LI>In response to <CODE>(laterThan ···)</CODE>,
|
||
removes the corresponding assertions</LI></UL></TD></TR><TR class="ghosted"><TD colspan="2"><pre style="background-color: rgba(192,192,255,1.0);"><code class="scheme">(spawn (on (asserted <MARK>(observe (dns-entry $name _))</MARK>)
|
||
<SPAN>(define deadline (+ (current-inexact-milliseconds) 2000))</SPAN>
|
||
(react <SPAN>(stop-when (asserted (later-than deadline)))</SPAN>
|
||
<SPAN>(assert (observe (dns-entry name _)))</SPAN>)))</code></pre></TD></TR></TABLE></section>
|
||
<section data-transition="none" class="stage-2"><TABLE class="summary-table"><TR style="background-color: rgba(255,192,192,1.0);"><TD>Client</TD><TD><UL><LI>Asserts <CODE>(observe (dns-entry "localhost" _))</CODE></LI><LI>When notified of a <CODE>(dns-entry "localhost" $addr)</CODE>, prints <CODE>addr</CODE> and quits</LI></UL></TD></TR><TR><TD colspan="2"><pre style="background-color: rgba(255,192,192,1.0);"><code class="scheme">(spawn <SPAN>(stop-when <MARK>(asserted (dns-entry "localhost" $addr))</MARK></SPAN>
|
||
<SPAN>(printf "localhost is ~a\n" addr))</SPAN>)</code></pre></TD></TR><TR style="background-color: rgba(240,255,192,1.0);"><TD>Server</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
looks up the <CODE>addr</CODE> for <CODE>name</CODE> and
|
||
asserts <CODE>(dns-entry name addr)</CODE></LI></UL></TD></TR><TR class="ghosted"><TD colspan="2"><pre style="background-color: rgba(240,255,192,1.0);"><code class="scheme">(spawn (during (observe (dns-entry $name _))
|
||
(define addr (engage-in-internet-dns-protocol-for name))
|
||
(assert (dns-entry name addr))))</code></pre></TD></TR><TR style="background-color: rgba(192,192,255,1.0);"><TD>Cache</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
asserts the same, and also <CODE>(observe (laterThan ···))</CODE></LI><LI>In response to <CODE>(laterThan ···)</CODE>,
|
||
removes the corresponding assertions</LI></UL></TD></TR><TR class="ghosted"><TD colspan="2"><pre style="background-color: rgba(192,192,255,1.0);"><code class="scheme">(spawn (on (asserted <SPAN>(observe (dns-entry $name _))</SPAN>)
|
||
<MARK>(define deadline (+ (current-inexact-milliseconds) 2000))</MARK>
|
||
(react <SPAN>(stop-when (asserted (later-than deadline)))</SPAN>
|
||
<SPAN>(assert (observe (dns-entry name _)))</SPAN>)))</code></pre></TD></TR></TABLE></section>
|
||
<section data-transition="none" class="stage-3"><TABLE class="summary-table"><TR style="background-color: rgba(255,192,192,1.0);"><TD>Client</TD><TD><UL><LI>Asserts <CODE>(observe (dns-entry "localhost" _))</CODE></LI><LI>When notified of a <CODE>(dns-entry "localhost" $addr)</CODE>, prints <CODE>addr</CODE> and quits</LI></UL></TD></TR><TR><TD colspan="2"><pre style="background-color: rgba(255,192,192,1.0);"><code class="scheme">(spawn <MARK>(stop-when <SPAN>(asserted (dns-entry "localhost" $addr))</SPAN></MARK>
|
||
<MARK>(printf "localhost is ~a\n" addr))</MARK>)</code></pre></TD></TR><TR style="background-color: rgba(240,255,192,1.0);"><TD>Server</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
looks up the <CODE>addr</CODE> for <CODE>name</CODE> and
|
||
asserts <CODE>(dns-entry name addr)</CODE></LI></UL></TD></TR><TR class="ghosted"><TD colspan="2"><pre style="background-color: rgba(240,255,192,1.0);"><code class="scheme">(spawn (during (observe (dns-entry $name _))
|
||
(define addr (engage-in-internet-dns-protocol-for name))
|
||
(assert (dns-entry name addr))))</code></pre></TD></TR><TR style="background-color: rgba(192,192,255,1.0);"><TD>Cache</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
asserts the same, and also <CODE>(observe (laterThan ···))</CODE></LI><LI>In response to <CODE>(laterThan ···)</CODE>,
|
||
removes the corresponding assertions</LI></UL></TD></TR><TR class="ghosted"><TD colspan="2"><pre style="background-color: rgba(192,192,255,1.0);"><code class="scheme">(spawn (on (asserted <SPAN>(observe (dns-entry $name _))</SPAN>)
|
||
<SPAN>(define deadline (+ (current-inexact-milliseconds) 2000))</SPAN>
|
||
(react <MARK>(stop-when (asserted (later-than deadline)))</MARK>
|
||
<SPAN>(assert (observe (dns-entry name _)))</SPAN>)))</code></pre></TD></TR></TABLE></section>
|
||
<section data-transition="none" class="stage-4"><TABLE class="summary-table"><TR style="background-color: rgba(255,192,192,1.0);"><TD>Client</TD><TD><UL><LI>Asserts <CODE>(observe (dns-entry "localhost" _))</CODE></LI><LI>When notified of a <CODE>(dns-entry "localhost" $addr)</CODE>, prints <CODE>addr</CODE> and quits</LI></UL></TD></TR><TR><TD colspan="2"><pre style="background-color: rgba(255,192,192,1.0);"><code class="scheme">(spawn <SPAN>(stop-when <SPAN>(asserted (dns-entry "localhost" $addr))</SPAN></SPAN>
|
||
<SPAN>(printf "localhost is ~a\n" addr))</SPAN>)</code></pre></TD></TR><TR style="background-color: rgba(240,255,192,1.0);"><TD>Server</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
looks up the <CODE>addr</CODE> for <CODE>name</CODE> and
|
||
asserts <CODE>(dns-entry name addr)</CODE></LI></UL></TD></TR><TR><TD colspan="2"><pre style="background-color: rgba(240,255,192,1.0);"><code class="scheme">(spawn (<MARK>on</MARK> (<MARK>asserted</MARK> (observe (dns-entry $name _)))
|
||
(<MARK>react</MARK> (<MARK>stop-when</MARK> (<MARK>retracted</MARK> (observe (dns-entry ···))))
|
||
(assert (dns-entry "localhost" ···)))))</code></pre></TD></TR><TR style="background-color: rgba(192,192,255,1.0);"><TD>Cache</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
asserts the same, and also <CODE>(observe (laterThan ···))</CODE></LI><LI>In response to <CODE>(laterThan ···)</CODE>,
|
||
removes the corresponding assertions</LI></UL></TD></TR><TR class="ghosted"><TD colspan="2"><pre style="background-color: rgba(192,192,255,1.0);"><code class="scheme">(spawn (on (asserted <SPAN>(observe (dns-entry $name _))</SPAN>)
|
||
<SPAN>(define deadline (+ (current-inexact-milliseconds) 2000))</SPAN>
|
||
(react <SPAN>(stop-when (asserted (later-than deadline)))</SPAN>
|
||
<MARK>(assert (observe (dns-entry name _)))</MARK>)))</code></pre></TD></TR></TABLE></section>
|
||
<section data-transition="none" class="stage-5"><TABLE class="summary-table"><TR style="background-color: rgba(255,192,192,1.0);"><TD>Client</TD><TD><UL><LI>Asserts <CODE>(observe (dns-entry "localhost" _))</CODE></LI><LI>When notified of a <CODE>(dns-entry "localhost" $addr)</CODE>, prints <CODE>addr</CODE> and quits</LI></UL></TD></TR><TR><TD colspan="2"><pre style="background-color: rgba(255,192,192,1.0);"><code class="scheme">(spawn <SPAN>(stop-when <SPAN>(asserted (dns-entry "localhost" $addr))</SPAN></SPAN>
|
||
<SPAN>(printf "localhost is ~a\n" addr))</SPAN>)</code></pre></TD></TR><TR style="background-color: rgba(240,255,192,1.0);"><TD>Server</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
looks up the <CODE>addr</CODE> for <CODE>name</CODE> and
|
||
asserts <CODE>(dns-entry name addr)</CODE></LI></UL></TD></TR><TR><TD colspan="2"><pre style="background-color: rgba(240,255,192,1.0);"><code class="scheme">(spawn (during (observe (dns-entry $name _))
|
||
(define addr (engage-in-internet-dns-protocol-for name))
|
||
(assert (dns-entry name addr))))</code></pre></TD></TR><TR style="background-color: rgba(192,192,255,1.0);"><TD>Cache</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
asserts the same, and also <CODE>(observe (laterThan ···))</CODE></LI><LI>In response to <CODE>(laterThan ···)</CODE>,
|
||
removes the corresponding assertions</LI></UL></TD></TR><TR class="ghosted"><TD colspan="2"><pre style="background-color: rgba(192,192,255,1.0);"><code class="scheme">(spawn (on (asserted <SPAN>(observe (dns-entry $name _))</SPAN>)
|
||
<SPAN>(define deadline (+ (current-inexact-milliseconds) 2000))</SPAN>
|
||
(react <SPAN>(stop-when (asserted (later-than deadline)))</SPAN>
|
||
<SPAN>(assert (observe (dns-entry name _)))</SPAN>)))</code></pre></TD></TR></TABLE></section>
|
||
<section data-transition="none" class="stage-6"><TABLE class="summary-table"><TR style="background-color: rgba(255,192,192,1.0);"><TD>Client</TD><TD><UL><LI>Asserts <CODE>(observe (dns-entry "localhost" _))</CODE></LI><LI>When notified of a <CODE>(dns-entry "localhost" $addr)</CODE>, prints <CODE>addr</CODE> and quits</LI></UL></TD></TR><TR><TD colspan="2"><pre style="background-color: rgba(255,192,192,1.0);"><code class="scheme">(spawn <SPAN>(stop-when <SPAN>(asserted (dns-entry "localhost" $addr))</SPAN></SPAN>
|
||
<SPAN>(printf "localhost is ~a\n" addr))</SPAN>)</code></pre></TD></TR><TR style="background-color: rgba(240,255,192,1.0);"><TD>Server</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
looks up the <CODE>addr</CODE> for <CODE>name</CODE> and
|
||
asserts <CODE>(dns-entry name addr)</CODE></LI></UL></TD></TR><TR><TD colspan="2"><pre style="background-color: rgba(240,255,192,1.0);"><code class="scheme">(spawn (during (observe (dns-entry $name _))
|
||
(define addr (engage-in-internet-dns-protocol-for name))
|
||
(assert (dns-entry name addr))))</code></pre></TD></TR><TR style="background-color: rgba(192,192,255,1.0);"><TD>Cache</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
asserts the same, and also <CODE>(observe (laterThan ···))</CODE></LI><LI>In response to <CODE>(laterThan ···)</CODE>,
|
||
removes the corresponding assertions</LI></UL></TD></TR><TR><TD colspan="2"><pre style="background-color: rgba(192,192,255,1.0);"><code class="scheme">(spawn (on (asserted <SPAN>(observe (dns-entry $name _))</SPAN>)
|
||
<SPAN>(define deadline (+ (current-inexact-milliseconds) 2000))</SPAN>
|
||
(react <SPAN>(stop-when (asserted (later-than deadline)))</SPAN>
|
||
<SPAN>(assert (observe (dns-entry name _)))</SPAN>)))</code></pre></TD></TR></TABLE></section>
|
||
<section data-transition="none" class="stage-7"><TABLE class="summary-table"><TR style="background-color: rgba(255,192,192,1.0);"><TD>Client</TD><TD><UL><LI>Asserts <CODE>(observe (dns-entry "localhost" _))</CODE></LI><LI>When notified of a <CODE>(dns-entry "localhost" $addr)</CODE>, prints <CODE>addr</CODE> and quits</LI></UL></TD></TR><TR><TD colspan="2"><pre style="background-color: rgba(255,192,192,1.0);"><code class="scheme">(spawn <SPAN>(stop-when <SPAN>(asserted (dns-entry "localhost" $addr))</SPAN></SPAN>
|
||
<SPAN>(printf "localhost is ~a\n" addr))</SPAN>)</code></pre></TD></TR><TR style="background-color: rgba(240,255,192,1.0);"><TD>Server</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
looks up the <CODE>addr</CODE> for <CODE>name</CODE> and
|
||
asserts <CODE>(dns-entry name addr)</CODE></LI></UL></TD></TR><TR><TD colspan="2"><pre style="background-color: rgba(240,255,192,1.0);"><code class="scheme">(spawn (during (observe (dns-entry $name _))
|
||
(define addr (engage-in-internet-dns-protocol-for name))
|
||
(assert (dns-entry name addr))))</code></pre></TD></TR><TR style="background-color: rgba(192,192,255,1.0);"><TD>Cache</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
asserts the same, and also <CODE>(observe (laterThan ···))</CODE></LI><LI>In response to <CODE>(laterThan ···)</CODE>,
|
||
removes the corresponding assertions</LI></UL></TD></TR><TR><TD colspan="2"><pre style="background-color: rgba(192,192,255,1.0);"><code class="scheme">(spawn (on (asserted <MARK>(observe (dns-entry $name _))</MARK>)
|
||
<SPAN>(define deadline (+ (current-inexact-milliseconds) 2000))</SPAN>
|
||
(react <SPAN>(stop-when (asserted (later-than deadline)))</SPAN>
|
||
<SPAN>(assert (observe (dns-entry name _)))</SPAN>)))</code></pre></TD></TR></TABLE></section>
|
||
<section data-transition="none" class="stage-8"><TABLE class="summary-table"><TR style="background-color: rgba(255,192,192,1.0);"><TD>Client</TD><TD><UL><LI>Asserts <CODE>(observe (dns-entry "localhost" _))</CODE></LI><LI>When notified of a <CODE>(dns-entry "localhost" $addr)</CODE>, prints <CODE>addr</CODE> and quits</LI></UL></TD></TR><TR><TD colspan="2"><pre style="background-color: rgba(255,192,192,1.0);"><code class="scheme">(spawn <SPAN>(stop-when <SPAN>(asserted (dns-entry "localhost" $addr))</SPAN></SPAN>
|
||
<SPAN>(printf "localhost is ~a\n" addr))</SPAN>)</code></pre></TD></TR><TR style="background-color: rgba(240,255,192,1.0);"><TD>Server</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
looks up the <CODE>addr</CODE> for <CODE>name</CODE> and
|
||
asserts <CODE>(dns-entry name addr)</CODE></LI></UL></TD></TR><TR><TD colspan="2"><pre style="background-color: rgba(240,255,192,1.0);"><code class="scheme">(spawn (during (observe (dns-entry $name _))
|
||
(define addr (engage-in-internet-dns-protocol-for name))
|
||
(assert (dns-entry name addr))))</code></pre></TD></TR><TR style="background-color: rgba(192,192,255,1.0);"><TD>Cache</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
asserts the same, and also <CODE>(observe (laterThan ···))</CODE></LI><LI>In response to <CODE>(laterThan ···)</CODE>,
|
||
removes the corresponding assertions</LI></UL></TD></TR><TR><TD colspan="2"><pre style="background-color: rgba(192,192,255,1.0);"><code class="scheme">(spawn (on (asserted <SPAN>(observe (dns-entry $name _))</SPAN>)
|
||
<MARK>(define deadline (+ (current-inexact-milliseconds) 2000))</MARK>
|
||
(react <SPAN>(stop-when (asserted (later-than deadline)))</SPAN>
|
||
<SPAN>(assert (observe (dns-entry name _)))</SPAN>)))</code></pre></TD></TR></TABLE></section>
|
||
<section data-transition="none" class="stage-9"><TABLE class="summary-table"><TR style="background-color: rgba(255,192,192,1.0);"><TD>Client</TD><TD><UL><LI>Asserts <CODE>(observe (dns-entry "localhost" _))</CODE></LI><LI>When notified of a <CODE>(dns-entry "localhost" $addr)</CODE>, prints <CODE>addr</CODE> and quits</LI></UL></TD></TR><TR><TD colspan="2"><pre style="background-color: rgba(255,192,192,1.0);"><code class="scheme">(spawn <SPAN>(stop-when <SPAN>(asserted (dns-entry "localhost" $addr))</SPAN></SPAN>
|
||
<SPAN>(printf "localhost is ~a\n" addr))</SPAN>)</code></pre></TD></TR><TR style="background-color: rgba(240,255,192,1.0);"><TD>Server</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
looks up the <CODE>addr</CODE> for <CODE>name</CODE> and
|
||
asserts <CODE>(dns-entry name addr)</CODE></LI></UL></TD></TR><TR><TD colspan="2"><pre style="background-color: rgba(240,255,192,1.0);"><code class="scheme">(spawn (during (observe (dns-entry $name _))
|
||
(define addr (engage-in-internet-dns-protocol-for name))
|
||
(assert (dns-entry name addr))))</code></pre></TD></TR><TR style="background-color: rgba(192,192,255,1.0);"><TD>Cache</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
asserts the same, and also <CODE>(observe (laterThan ···))</CODE></LI><LI>In response to <CODE>(laterThan ···)</CODE>,
|
||
removes the corresponding assertions</LI></UL></TD></TR><TR><TD colspan="2"><pre style="background-color: rgba(192,192,255,1.0);"><code class="scheme">(spawn (on (asserted <SPAN>(observe (dns-entry $name _))</SPAN>)
|
||
<SPAN>(define deadline (+ (current-inexact-milliseconds) 2000))</SPAN>
|
||
(react <MARK>(stop-when (asserted (later-than deadline)))</MARK>
|
||
<SPAN>(assert (observe (dns-entry name _)))</SPAN>)))</code></pre></TD></TR></TABLE></section>
|
||
<section data-transition="none" class="stage-10"><TABLE class="summary-table"><TR style="background-color: rgba(255,192,192,1.0);"><TD>Client</TD><TD><UL><LI>Asserts <CODE>(observe (dns-entry "localhost" _))</CODE></LI><LI>When notified of a <CODE>(dns-entry "localhost" $addr)</CODE>, prints <CODE>addr</CODE> and quits</LI></UL></TD></TR><TR><TD colspan="2"><pre style="background-color: rgba(255,192,192,1.0);"><code class="scheme">(spawn <SPAN>(stop-when <SPAN>(asserted (dns-entry "localhost" $addr))</SPAN></SPAN>
|
||
<SPAN>(printf "localhost is ~a\n" addr))</SPAN>)</code></pre></TD></TR><TR style="background-color: rgba(240,255,192,1.0);"><TD>Server</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
looks up the <CODE>addr</CODE> for <CODE>name</CODE> and
|
||
asserts <CODE>(dns-entry name addr)</CODE></LI></UL></TD></TR><TR><TD colspan="2"><pre style="background-color: rgba(240,255,192,1.0);"><code class="scheme">(spawn (during (observe (dns-entry $name _))
|
||
(define addr (engage-in-internet-dns-protocol-for name))
|
||
(assert (dns-entry name addr))))</code></pre></TD></TR><TR style="background-color: rgba(192,192,255,1.0);"><TD>Cache</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
asserts the same, and also <CODE>(observe (laterThan ···))</CODE></LI><LI>In response to <CODE>(laterThan ···)</CODE>,
|
||
removes the corresponding assertions</LI></UL></TD></TR><TR><TD colspan="2"><pre style="background-color: rgba(192,192,255,1.0);"><code class="scheme">(spawn (on (asserted <SPAN>(observe (dns-entry $name _))</SPAN>)
|
||
<SPAN>(define deadline (+ (current-inexact-milliseconds) 2000))</SPAN>
|
||
(react <SPAN>(stop-when (asserted (later-than deadline)))</SPAN>
|
||
<MARK>(assert (observe (dns-entry name _)))</MARK>)))</code></pre></TD></TR></TABLE></section>
|
||
<section data-transition="none" class="stage-11"><TABLE class="summary-table"><TR style="background-color: rgba(255,192,192,1.0);"><TD>Client</TD><TD><UL><LI>Asserts <CODE>(observe (dns-entry "localhost" _))</CODE></LI><LI>When notified of a <CODE>(dns-entry "localhost" $addr)</CODE>, prints <CODE>addr</CODE> and quits</LI></UL></TD></TR><TR><TD colspan="2"><pre style="background-color: rgba(255,192,192,1.0);"><code class="scheme">(spawn <SPAN>(stop-when <SPAN>(asserted (dns-entry "localhost" $addr))</SPAN></SPAN>
|
||
<SPAN>(printf "localhost is ~a\n" addr))</SPAN>)</code></pre></TD></TR><TR style="background-color: rgba(240,255,192,1.0);"><TD>Server</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
looks up the <CODE>addr</CODE> for <CODE>name</CODE> and
|
||
asserts <CODE>(dns-entry name addr)</CODE></LI></UL></TD></TR><TR><TD colspan="2"><pre style="background-color: rgba(240,255,192,1.0);"><code class="scheme">(spawn (during (observe (dns-entry $name _))
|
||
(define addr (engage-in-internet-dns-protocol-for name))
|
||
(assert (dns-entry name addr))))</code></pre></TD></TR><TR style="background-color: rgba(192,192,255,1.0);"><TD>Cache</TD><TD><UL><LI>Asserts <CODE>(observe (observe (dns-entry _ _)))</CODE></LI><LI>In response to <CODE>(observe (dns-entry $name _))</CODE>,
|
||
asserts the same, and also <CODE>(observe (laterThan ···))</CODE></LI><LI>In response to <CODE>(laterThan ···)</CODE>,
|
||
removes the corresponding assertions</LI></UL></TD></TR><TR><TD colspan="2"><pre style="background-color: rgba(192,192,255,1.0);"><code class="scheme">(spawn (on (asserted <SPAN>(observe (dns-entry $name _))</SPAN>)
|
||
<SPAN>(define deadline (+ (current-inexact-milliseconds) 2000))</SPAN>
|
||
(react <SPAN>(stop-when (asserted (later-than deadline)))</SPAN>
|
||
<SPAN>(assert (observe (dns-entry name _)))</SPAN>)))</code></pre></TD></TR></TABLE></section></section>
|
||
<section data-transition="none" class="stage-0"><DIV><img src="slides/ch5-stx-programs.png" style="width: 30%;"/><img src="slides/ch5-stx-trees.png" style="width: 50%;"/></DIV><H3>Figures 16 & 17, chapter 5</H3><aside class="notes"><P>The dissertation includes a stripped-back description
|
||
of the new language features in a very small
|
||
host language called <SPAN class="language-name">Syndicate/λ</SPAN></P><P>The syntax and reduction rules that explain the features
|
||
are in chapter 5 of the dissertation</P></aside></section>
|
||
<section data-transition="none" class="stage-0"><DIV><img src="slides/ch5-reductions1.png" style="width: 40%;"/><img src="slides/ch5-reductions2.png" style="width: 40%;"/></DIV><H3>Figures 19 & 20, chapter 5</H3></section>
|
||
<section data-transition="none" class="stage-0"><DIV><img src="slides/ch5-judgements.png" style="width: 45%;"/></DIV><H3>Figure 23, chapter 5</H3><aside class="notes"><P>The same chapter lays out a "well-formedness" judgement,
|
||
which will form the heart of a soundness argument
|
||
that programmers can rely on.</P></aside></section>
|
||
<section data-transition="none" class="stage-0"><H3>Roadmap</H3><OL><LI>Dataspace model and assertion tries</LI><LI>Reifying conversations</LI><LI class="highlighted">Programming experience with <SPAN class="language-name">Syndicate</SPAN></LI><LI>Evaluation</LI><LI>Conclusion & future work</LI></OL></section>
|
||
<section data-transition="none" class="stage-0"><H3><SPAN class="language-name">Syndicate/js</SPAN></H3><P>In-browser and node.js implementation</P><P>Assertions can place DOM elements on the page</P><P>DOM events generate <SPAN class="language-name">Syndicate/js</SPAN> messages</P><P>Websocket protocol connects browser to <SPAN class="language-name">Syndicate/rkt</SPAN></P></section>
|
||
<section data-transition="none" class="stage-0"><DIV><img src="slides/pljs-todo-screenshot.png" style="width: 100%;"/></DIV></section>
|
||
<section data-transition="none" class="stage-0"><pre style="width: 100%;"><code class="scheme">function todoListItemModel(initialId, initialTitle, initialCompleted) {
|
||
<SPAN>spawn</SPAN> {
|
||
<SPAN> field this.id = initialId;
|
||
field this.title = initialTitle;
|
||
field this.completed = initialCompleted;</SPAN>
|
||
|
||
<SPAN> stop on message deleteTodo(this.id);
|
||
</SPAN>
|
||
<SPAN> assert todo(this.id, this.title, this.completed);
|
||
</SPAN>
|
||
<SPAN> on message setCompleted(this.id, $v) { this.completed = v; }
|
||
on message setAllCompleted($v) { this.completed = v; }
|
||
|
||
on message setTitle(this.id, $v) { this.title = v; }
|
||
|
||
on message clearCompletedTodos() {
|
||
if (this.completed) :: deleteTodo(this.id);
|
||
}
|
||
</SPAN> }
|
||
}</code></pre><aside class="notes"><P>It's more or less a curly-brace version of the same
|
||
additions to the language</P></aside></section>
|
||
<section data-transition="none" class="stage-0"><img src="slides/game-screenshot.png"/><aside class="notes"><P>And of course we built a few other reasonably large programs.</P><P>This is a 2D platform game written in <SPAN class="language-name">Syndicate/rkt</SPAN>.</P><P>Everything you see on screen is an assertion.</P></aside></section>
|
||
<section data-transition="none" class="stage-0"><img src="slides/syndicate-gui-snapshot.png"/><aside class="notes"><P>The same is true for this windowing system.</P><P>Another nice feature is the window-list on the bottom.
|
||
Both that and the windows themselves are from
|
||
the same assertion.</P><P>Good fault-tolerance properties.</P></aside></section>
|
||
<section data-transition="none" class="stage-0"><UL><LI>IRC Server</LI><LI>TCP/IP Stack</LI><LI>Collaborative text editor server</LI><LI>Broker: embeds <SPAN class="language-name">Syndicate/js</SPAN> in <SPAN class="language-name">Syndicate/rkt</SPAN></LI><LI>Web-based chat application</LI><LI>Many, many, many smaller examples</LI></UL><P><I><a href="http://syndicate-lang.org/">http://syndicate-lang.org/</a></I></P></section>
|
||
<section data-transition="none" class="stage-0"><H3>Roadmap</H3><OL><LI>Dataspace model and assertion tries</LI><LI>Reifying conversations</LI><LI>Programming experience with <SPAN class="language-name">Syndicate</SPAN></LI><LI class="highlighted">Evaluation</LI><LI>Conclusion & future work</LI></OL></section>
|
||
<section data-transition="none" class="stage-0"><section data-transition="none" class="stage-0"><H4>How should we evaluate a language design idea?</H4><TABLE class="summary-table"><TR><TD class="ghosted">Quantitatively?</TD><TD><SPAN class="ghosted"><SPAN class="cross-mark">✗</SPAN> Benchmark suites<BR/></SPAN>
|
||
<SPAN class="ghosted"><SPAN class="cross-mark">✗</SPAN> Error rates<BR/></SPAN>
|
||
<SPAN class="ghosted"><SPAN class="cross-mark">✗</SPAN> Programmer productivity<BR/></SPAN></TD></TR><TR><TD class="ghosted">Qualitatively</TD><TD><SPAN class="ghosted"><SPAN class="check-mark">✓</SPAN> Simplification of programs<BR/></SPAN>
|
||
<SPAN class="ghosted"><SPAN class="check-mark">✓</SPAN> Asymptotic performance<BR/></SPAN></TD></TR></TABLE></section>
|
||
<section data-transition="none" class="stage-1"><H4>How should we evaluate a language design idea?</H4><TABLE class="summary-table"><TR><TD>Quantitatively?</TD><TD><SPAN class="ghosted"><SPAN class="cross-mark">✗</SPAN> Benchmark suites<BR/></SPAN>
|
||
<SPAN class="ghosted"><SPAN class="cross-mark">✗</SPAN> Error rates<BR/></SPAN>
|
||
<SPAN class="ghosted"><SPAN class="cross-mark">✗</SPAN> Programmer productivity<BR/></SPAN></TD></TR><TR><TD class="ghosted">Qualitatively</TD><TD><SPAN class="ghosted"><SPAN class="check-mark">✓</SPAN> Simplification of programs<BR/></SPAN>
|
||
<SPAN class="ghosted"><SPAN class="check-mark">✓</SPAN> Asymptotic performance<BR/></SPAN></TD></TR></TABLE></section>
|
||
<section data-transition="none" class="stage-2"><H4>How should we evaluate a language design idea?</H4><TABLE class="summary-table"><TR><TD>Quantitatively?</TD><TD><SPAN><SPAN class="cross-mark">✗</SPAN> Benchmark suites<BR/></SPAN>
|
||
<SPAN class="ghosted"><SPAN class="cross-mark">✗</SPAN> Error rates<BR/></SPAN>
|
||
<SPAN class="ghosted"><SPAN class="cross-mark">✗</SPAN> Programmer productivity<BR/></SPAN></TD></TR><TR><TD class="ghosted">Qualitatively</TD><TD><SPAN class="ghosted"><SPAN class="check-mark">✓</SPAN> Simplification of programs<BR/></SPAN>
|
||
<SPAN class="ghosted"><SPAN class="check-mark">✓</SPAN> Asymptotic performance<BR/></SPAN></TD></TR></TABLE></section>
|
||
<section data-transition="none" class="stage-3"><H4>How should we evaluate a language design idea?</H4><TABLE class="summary-table"><TR><TD>Quantitatively?</TD><TD><SPAN><SPAN class="cross-mark">✗</SPAN> Benchmark suites<BR/></SPAN>
|
||
<SPAN><SPAN class="cross-mark">✗</SPAN> Error rates<BR/></SPAN>
|
||
<SPAN class="ghosted"><SPAN class="cross-mark">✗</SPAN> Programmer productivity<BR/></SPAN></TD></TR><TR><TD class="ghosted">Qualitatively</TD><TD><SPAN class="ghosted"><SPAN class="check-mark">✓</SPAN> Simplification of programs<BR/></SPAN>
|
||
<SPAN class="ghosted"><SPAN class="check-mark">✓</SPAN> Asymptotic performance<BR/></SPAN></TD></TR></TABLE></section>
|
||
<section data-transition="none" class="stage-4"><H4>How should we evaluate a language design idea?</H4><TABLE class="summary-table"><TR><TD>Quantitatively?</TD><TD><SPAN><SPAN class="cross-mark">✗</SPAN> Benchmark suites<BR/></SPAN>
|
||
<SPAN><SPAN class="cross-mark">✗</SPAN> Error rates<BR/></SPAN>
|
||
<SPAN><SPAN class="cross-mark">✗</SPAN> Programmer productivity<BR/></SPAN></TD></TR><TR><TD class="ghosted">Qualitatively</TD><TD><SPAN class="ghosted"><SPAN class="check-mark">✓</SPAN> Simplification of programs<BR/></SPAN>
|
||
<SPAN class="ghosted"><SPAN class="check-mark">✓</SPAN> Asymptotic performance<BR/></SPAN></TD></TR></TABLE></section>
|
||
<section data-transition="none" class="stage-5"><H4>How should we evaluate a language design idea?</H4><TABLE class="summary-table"><TR><TD>Quantitatively?</TD><TD><SPAN><SPAN class="cross-mark">✗</SPAN> Benchmark suites<BR/></SPAN>
|
||
<SPAN><SPAN class="cross-mark">✗</SPAN> Error rates<BR/></SPAN>
|
||
<SPAN><SPAN class="cross-mark">✗</SPAN> Programmer productivity<BR/></SPAN></TD></TR><TR><TD>Qualitatively</TD><TD><SPAN class="ghosted"><SPAN class="check-mark">✓</SPAN> Simplification of programs<BR/></SPAN>
|
||
<SPAN class="ghosted"><SPAN class="check-mark">✓</SPAN> Asymptotic performance<BR/></SPAN></TD></TR></TABLE></section>
|
||
<section data-transition="none" class="stage-6"><H4>How should we evaluate a language design idea?</H4><TABLE class="summary-table"><TR><TD>Quantitatively?</TD><TD><SPAN><SPAN class="cross-mark">✗</SPAN> Benchmark suites<BR/></SPAN>
|
||
<SPAN><SPAN class="cross-mark">✗</SPAN> Error rates<BR/></SPAN>
|
||
<SPAN><SPAN class="cross-mark">✗</SPAN> Programmer productivity<BR/></SPAN></TD></TR><TR><TD>Qualitatively</TD><TD><SPAN><SPAN class="check-mark">✓</SPAN> Simplification of programs<BR/></SPAN>
|
||
<SPAN class="ghosted"><SPAN class="check-mark">✓</SPAN> Asymptotic performance<BR/></SPAN></TD></TR></TABLE></section>
|
||
<section data-transition="none" class="stage-7"><H4>How should we evaluate a language design idea?</H4><TABLE class="summary-table"><TR><TD>Quantitatively?</TD><TD><SPAN><SPAN class="cross-mark">✗</SPAN> Benchmark suites<BR/></SPAN>
|
||
<SPAN><SPAN class="cross-mark">✗</SPAN> Error rates<BR/></SPAN>
|
||
<SPAN><SPAN class="cross-mark">✗</SPAN> Programmer productivity<BR/></SPAN></TD></TR><TR><TD>Qualitatively</TD><TD><SPAN><SPAN class="check-mark">✓</SPAN> Simplification of programs<BR/></SPAN>
|
||
<SPAN><SPAN class="check-mark">✓</SPAN> Asymptotic performance<BR/></SPAN></TD></TR></TABLE></section></section>
|
||
<section data-transition="none" class="stage-0"><section data-transition="none" class="stage-0"><H3>Patterns</H3><DIV class="switch-container" style="height: 4em;"><P>Simplify by eliminating patterns.</P></DIV></section>
|
||
<section data-transition="none" class="stage-1"><H3>Patterns</H3><DIV class="switch-container" style="height: 4em;"><DIV><P>Programming Pattern [Felleisen 1991]</P><P>Design Pattern [Gamma et al. 1994]</P></DIV></DIV></section></section>
|
||
<section data-transition="none" class="stage-0"><P>Informal → Formal → Invisible</P><P>[Norvig 1996]</P></section>
|
||
<section data-transition="none" class="stage-0"><OL><LI>Event Broadcast (encoding)</LI><LI>The "Observer" Pattern [Gamma et al. 1994]</LI><LI>State Replication Pattern<BR/><BR/></LI><LI>The "State" Pattern [Gamma et al. 1994]<BR/><BR/></LI><LI>The "Cancellation" Pattern [Russell et al. 2016]</LI></OL></section>
|
||
<section data-transition="none" class="stage-0 state-replication-pattern"><H3>State Replication</H3><TABLE><TR><TD></TD><TD>Event broadcasting</TD><TD>Observer pattern</TD><TD>State replication</TD></TR><TR><TH>Smalltalk</TH><TD>informal/invisible</TD><TD>formal</TD><TD>informal</TD></TR><TR><TH>Ruby</TH><TD>informal/invisible</TD><TD>formal</TD><TD>informal</TD></TR><TR><TH>Java</TH><TD>informal/invisible</TD><TD>informal</TD><TD>informal</TD></TR><TR><TH>Erlang/OTP</TH><TD>informal/invisible</TD><TD>informal</TD><TD>informal</TD></TR><TR><TH><SPAN class="language-name">Syndicate</SPAN></TH><TD class="reddish">invisible</TD><TD class="reddish">invisible</TD><TD class="reddish">invisible</TD></TR></TABLE></section>
|
||
<section data-transition="none" class="stage-0"><H3>"State" Pattern</H3><TABLE><TR><TH>Java</TH><TD>informal</TD></TR><TR><TH><SPAN class="language-name">Syndicate</SPAN></TH><TD class="reddish">invisible</TD></TR></TABLE></section>
|
||
<section data-transition="none" class="stage-0"><H3>"Cancellation" Pattern</H3><TABLE><TR><TH>JavaScript</TH><TD>informal</TD></TR><TR><TH><SPAN class="language-name">Syndicate</SPAN></TH><TD class="reddish">invisible</TD></TR></TABLE></section>
|
||
<section data-transition="none" class="stage-0"><pre><code class="scheme">(struct service-a (request response))
|
||
(struct service-b (request response))
|
||
|
||
(spawn (during (service-a 'request-from-a $response)
|
||
(on-start (printf "Response: ~v\n" response))))
|
||
|
||
(spawn (during (observe (service-a $req-a _))
|
||
(during (service-b 'request-from-b $resp-b)
|
||
(assert (service-a req-a (make-answer resp-b))))))</code></pre></section>
|
||
<section data-transition="none" class="stage-0 asymptotic-performance"><H3>Asymptotic performance</H3><P class="green">Message routing & delivery, sec/event vs k</P><TABLE class="no-dividers"><TR><TD><img src="Figures/performance/cost-per-msg.svg"/><BR/>Unicast: Õ(1)</TD><TD><img src="Figures/performance/cost-per-broadcast.svg"/><BR/>Broadcast: Õ(1/k + 1)</TD></TR></TABLE><aside class="notes"><P>Message-routing and -delivery as expected</P></aside></section>
|
||
<section data-transition="none" class="stage-0 asymptotic-performance"><H3>Asymptotic performance</H3><P class="green">Assertion set update cost, sec/event vs k</P><TABLE class="no-dividers"><TR><TD><img src="Figures/performance/cost-per-scn-1.svg"/><BR/>k-independent: Õ(1)</TD><TD><img src="Figures/performance/cost-per-scn-2.svg"/><BR/>k-dependent: Õ(1)</TD></TR></TABLE><aside class="notes"><P>Complex space</P><P>A few extreme points in this space: no surprises</P></aside></section>
|
||
<section data-transition="none" class="stage-0 asymptotic-performance"><H3>Asymptotic performance</H3><P class="green">TCP echo server, sec/conn vs k</P><TABLE class="no-dividers"><TR><TD colspan="2"><img src="Figures/performance/echo-server-cost.svg"/><BR/>Marginal cost of additional connection: Õ(1)</TD></TR></TABLE></section>
|
||
<section data-transition="none" class="stage-0"><H3>Roadmap</H3><OL><LI>Dataspace model and assertion tries</LI><LI>Reifying conversations</LI><LI>Programming experience with <SPAN class="language-name">Syndicate</SPAN></LI><LI>Evaluation</LI><LI class="highlighted">Conclusion & future work</LI></OL></section>
|
||
<section class="thesis-expanded stage-0" data-transition="none"><H3><SPAN><SPAN class="language-name">Syndicate</SPAN> provides a...</SPAN></H3><TABLE class="no-dividers fullwidth"><TR><TD>new</TD><TD>→</TD><TD>design landscape</TD></TR><TR><TD>effective</TD><TD>→</TD><TD>evaluation</TD></TR><TR><TD>realizable</TD><TD>→</TD><TD><SPAN>prototypes, tries</SPAN></TD></TR><TR><TD>linguistic</TD><TD>→</TD><TD>reified conversations</TD></TR><TR><TD>mechanism for sharing state</TD><TD>→</TD><TD>dataspace model</TD></TR></TABLE><P>in a concurrent setting.</P></section>
|
||
<section data-transition="none" class="stage-0"><section data-transition="none" class="stage-0"><H3>Future Work</H3><UL><LI>Enhancements to the formal models<BR/><SMALL>types; names; grouping & relaying; formal properties</SMALL></LI><LI>System model<BR/><SMALL>performance; tool support; generic protocols; process management;<BR/>stdio; contracts; security; persistence; polyglot</SMALL></LI><LI>Distributed systems<BR/><SMALL>unpredictable latency & scheduling; message loss; subnets</SMALL></LI></UL><DIV class="ghosted"><H3>Thank you!</H3><SMALL>Committee: Thank You for Signing my Dissertation! :-)</SMALL></DIV></section>
|
||
<section data-transition="none" class="stage-1"><H3>Future Work</H3><UL><LI>Enhancements to the formal models<BR/><SMALL>types; names; grouping & relaying; formal properties</SMALL></LI><LI>System model<BR/><SMALL>performance; tool support; generic protocols; process management;<BR/>stdio; contracts; security; persistence; polyglot</SMALL></LI><LI>Distributed systems<BR/><SMALL>unpredictable latency & scheduling; message loss; subnets</SMALL></LI></UL><DIV><H3>Thank you!</H3><SMALL>Committee: Thank You for Signing my Dissertation! :-)</SMALL></DIV></section></section>
|
||
<section data-transition="none" class="stage-0"><H3>Backup</H3></section>
|
||
<section data-transition="none" class="stage-0"><section data-transition="none" class="stage-0"><TABLE class="summary-table"><TR><TD class="medium">New expressions:</TD><TD><pre style="width: 100%;"><code class="scheme"><SPAN>(spawn <EM>endpoint-expr</EM> ...)</SPAN>
|
||
<SPAN>(spawn* <EM>expr</EM> ...)</SPAN>
|
||
<SPAN>(dataspace <EM>expr</EM> ...)</SPAN>
|
||
<SPAN>(react <EM>endpoint-expr</EM> ...)</SPAN>
|
||
<SPAN>(stop-facet <EM>facet-id-expr</EM> <EM>expr</EM> ...)</SPAN>
|
||
<SPAN>(current-facet-id)</SPAN>
|
||
<SPAN>(send! <EM>expr</EM>)</SPAN></code></pre></TD></TR><TR><TD class="medium">Field access:</TD><TD><pre><code class="scheme"><SPAN>(fieldname)</SPAN></code></pre></TD></TR><TR><TD class="medium">Field update:</TD><TD><pre><code class="scheme"><SPAN>(fieldname <EM>expr</EM>)</SPAN></code></pre></TD></TR></TABLE></section>
|
||
<section data-transition="none" class="stage-1"><TABLE class="summary-table"><TR><TD class="medium">New expressions:</TD><TD><pre style="width: 100%;"><code class="scheme"><MARK>(spawn <EM>endpoint-expr</EM> ...)</MARK>
|
||
<MARK>(spawn* <EM>expr</EM> ...)</MARK>
|
||
<SPAN>(dataspace <EM>expr</EM> ...)</SPAN>
|
||
<SPAN>(react <EM>endpoint-expr</EM> ...)</SPAN>
|
||
<SPAN>(stop-facet <EM>facet-id-expr</EM> <EM>expr</EM> ...)</SPAN>
|
||
<SPAN>(current-facet-id)</SPAN>
|
||
<SPAN>(send! <EM>expr</EM>)</SPAN></code></pre></TD></TR><TR><TD class="medium">Field access:</TD><TD><pre><code class="scheme"><SPAN>(fieldname)</SPAN></code></pre></TD></TR><TR><TD class="medium">Field update:</TD><TD><pre><code class="scheme"><SPAN>(fieldname <EM>expr</EM>)</SPAN></code></pre></TD></TR></TABLE></section>
|
||
<section data-transition="none" class="stage-2"><TABLE class="summary-table"><TR><TD class="medium">New expressions:</TD><TD><pre style="width: 100%;"><code class="scheme"><SPAN>(spawn <EM>endpoint-expr</EM> ...)</SPAN>
|
||
<SPAN>(spawn* <EM>expr</EM> ...)</SPAN>
|
||
<MARK>(dataspace <EM>expr</EM> ...)</MARK>
|
||
<SPAN>(react <EM>endpoint-expr</EM> ...)</SPAN>
|
||
<SPAN>(stop-facet <EM>facet-id-expr</EM> <EM>expr</EM> ...)</SPAN>
|
||
<SPAN>(current-facet-id)</SPAN>
|
||
<SPAN>(send! <EM>expr</EM>)</SPAN></code></pre></TD></TR><TR><TD class="medium">Field access:</TD><TD><pre><code class="scheme"><SPAN>(fieldname)</SPAN></code></pre></TD></TR><TR><TD class="medium">Field update:</TD><TD><pre><code class="scheme"><SPAN>(fieldname <EM>expr</EM>)</SPAN></code></pre></TD></TR></TABLE></section>
|
||
<section data-transition="none" class="stage-3"><TABLE class="summary-table"><TR><TD class="medium">New expressions:</TD><TD><pre style="width: 100%;"><code class="scheme"><SPAN>(spawn <EM>endpoint-expr</EM> ...)</SPAN>
|
||
<SPAN>(spawn* <EM>expr</EM> ...)</SPAN>
|
||
<SPAN>(dataspace <EM>expr</EM> ...)</SPAN>
|
||
<MARK>(react <EM>endpoint-expr</EM> ...)</MARK>
|
||
<SPAN>(stop-facet <EM>facet-id-expr</EM> <EM>expr</EM> ...)</SPAN>
|
||
<SPAN>(current-facet-id)</SPAN>
|
||
<SPAN>(send! <EM>expr</EM>)</SPAN></code></pre></TD></TR><TR><TD class="medium">Field access:</TD><TD><pre><code class="scheme"><SPAN>(fieldname)</SPAN></code></pre></TD></TR><TR><TD class="medium">Field update:</TD><TD><pre><code class="scheme"><SPAN>(fieldname <EM>expr</EM>)</SPAN></code></pre></TD></TR></TABLE></section>
|
||
<section data-transition="none" class="stage-4"><TABLE class="summary-table"><TR><TD class="medium">New expressions:</TD><TD><pre style="width: 100%;"><code class="scheme"><SPAN>(spawn <EM>endpoint-expr</EM> ...)</SPAN>
|
||
<SPAN>(spawn* <EM>expr</EM> ...)</SPAN>
|
||
<SPAN>(dataspace <EM>expr</EM> ...)</SPAN>
|
||
<SPAN>(react <EM>endpoint-expr</EM> ...)</SPAN>
|
||
<MARK>(stop-facet <EM>facet-id-expr</EM> <EM>expr</EM> ...)</MARK>
|
||
<MARK>(current-facet-id)</MARK>
|
||
<SPAN>(send! <EM>expr</EM>)</SPAN></code></pre></TD></TR><TR><TD class="medium">Field access:</TD><TD><pre><code class="scheme"><SPAN>(fieldname)</SPAN></code></pre></TD></TR><TR><TD class="medium">Field update:</TD><TD><pre><code class="scheme"><SPAN>(fieldname <EM>expr</EM>)</SPAN></code></pre></TD></TR></TABLE></section>
|
||
<section data-transition="none" class="stage-5"><TABLE class="summary-table"><TR><TD class="medium">New expressions:</TD><TD><pre style="width: 100%;"><code class="scheme"><SPAN>(spawn <EM>endpoint-expr</EM> ...)</SPAN>
|
||
<SPAN>(spawn* <EM>expr</EM> ...)</SPAN>
|
||
<SPAN>(dataspace <EM>expr</EM> ...)</SPAN>
|
||
<SPAN>(react <EM>endpoint-expr</EM> ...)</SPAN>
|
||
<SPAN>(stop-facet <EM>facet-id-expr</EM> <EM>expr</EM> ...)</SPAN>
|
||
<SPAN>(current-facet-id)</SPAN>
|
||
<MARK>(send! <EM>expr</EM>)</MARK></code></pre></TD></TR><TR><TD class="medium">Field access:</TD><TD><pre><code class="scheme"><SPAN>(fieldname)</SPAN></code></pre></TD></TR><TR><TD class="medium">Field update:</TD><TD><pre><code class="scheme"><SPAN>(fieldname <EM>expr</EM>)</SPAN></code></pre></TD></TR></TABLE></section>
|
||
<section data-transition="none" class="stage-6"><TABLE class="summary-table"><TR><TD class="medium">New expressions:</TD><TD><pre style="width: 100%;"><code class="scheme"><SPAN>(spawn <EM>endpoint-expr</EM> ...)</SPAN>
|
||
<SPAN>(spawn* <EM>expr</EM> ...)</SPAN>
|
||
<SPAN>(dataspace <EM>expr</EM> ...)</SPAN>
|
||
<SPAN>(react <EM>endpoint-expr</EM> ...)</SPAN>
|
||
<SPAN>(stop-facet <EM>facet-id-expr</EM> <EM>expr</EM> ...)</SPAN>
|
||
<SPAN>(current-facet-id)</SPAN>
|
||
<SPAN>(send! <EM>expr</EM>)</SPAN></code></pre></TD></TR><TR><TD class="medium">Field access:</TD><TD><pre><code class="scheme"><MARK>(fieldname)</MARK></code></pre></TD></TR><TR><TD class="medium">Field update:</TD><TD><pre><code class="scheme"><SPAN>(fieldname <EM>expr</EM>)</SPAN></code></pre></TD></TR></TABLE></section>
|
||
<section data-transition="none" class="stage-7"><TABLE class="summary-table"><TR><TD class="medium">New expressions:</TD><TD><pre style="width: 100%;"><code class="scheme"><SPAN>(spawn <EM>endpoint-expr</EM> ...)</SPAN>
|
||
<SPAN>(spawn* <EM>expr</EM> ...)</SPAN>
|
||
<SPAN>(dataspace <EM>expr</EM> ...)</SPAN>
|
||
<SPAN>(react <EM>endpoint-expr</EM> ...)</SPAN>
|
||
<SPAN>(stop-facet <EM>facet-id-expr</EM> <EM>expr</EM> ...)</SPAN>
|
||
<SPAN>(current-facet-id)</SPAN>
|
||
<SPAN>(send! <EM>expr</EM>)</SPAN></code></pre></TD></TR><TR><TD class="medium">Field access:</TD><TD><pre><code class="scheme"><SPAN>(fieldname)</SPAN></code></pre></TD></TR><TR><TD class="medium">Field update:</TD><TD><pre><code class="scheme"><MARK>(fieldname <EM>expr</EM>)</MARK></code></pre></TD></TR></TABLE></section>
|
||
<section data-transition="none" class="stage-8"><TABLE class="summary-table"><TR><TD class="medium">New expressions:</TD><TD><pre style="width: 100%;"><code class="scheme"><SPAN>(spawn <EM>endpoint-expr</EM> ...)</SPAN>
|
||
<SPAN>(spawn* <EM>expr</EM> ...)</SPAN>
|
||
<SPAN>(dataspace <EM>expr</EM> ...)</SPAN>
|
||
<SPAN>(react <EM>endpoint-expr</EM> ...)</SPAN>
|
||
<SPAN>(stop-facet <EM>facet-id-expr</EM> <EM>expr</EM> ...)</SPAN>
|
||
<SPAN>(current-facet-id)</SPAN>
|
||
<SPAN>(send! <EM>expr</EM>)</SPAN></code></pre></TD></TR><TR><TD class="medium">Field access:</TD><TD><pre><code class="scheme"><SPAN>(fieldname)</SPAN></code></pre></TD></TR><TR><TD class="medium">Field update:</TD><TD><pre><code class="scheme"><SPAN>(fieldname <EM>expr</EM>)</SPAN></code></pre></TD></TR></TABLE></section></section>
|
||
<section data-transition="none" class="stage-0"><section data-transition="none" class="stage-0"><pre style="width: 65%;"><code class="scheme"><SPAN>(struct set-box (new-value))
|
||
(struct box-state (value))</SPAN>
|
||
|
||
(spawn <SPAN>(field [current-value 0])</SPAN>
|
||
<SPAN><SPAN>(assert (box-state (current-value)))</SPAN></SPAN>
|
||
(on <SPAN>(message (set-box $new-value))</SPAN>
|
||
<SPAN>(current-value new-value)</SPAN>))
|
||
|
||
(spawn (on <SPAN>(asserted (box-state $v))</SPAN>
|
||
<SPAN>(send! (set-box (+ v 1)))</SPAN>))</code></pre></section>
|
||
<section data-transition="none" class="stage-1"><pre style="width: 65%;"><code class="scheme"><MARK>(struct set-box (new-value))
|
||
(struct box-state (value))</MARK>
|
||
|
||
(spawn <SPAN>(field [current-value 0])</SPAN>
|
||
<SPAN><SPAN>(assert (box-state (current-value)))</SPAN></SPAN>
|
||
(on <SPAN>(message (set-box $new-value))</SPAN>
|
||
<SPAN>(current-value new-value)</SPAN>))
|
||
|
||
(spawn (on <SPAN>(asserted (box-state $v))</SPAN>
|
||
<SPAN>(send! (set-box (+ v 1)))</SPAN>))</code></pre></section>
|
||
<section data-transition="none" class="stage-2"><pre style="width: 65%;"><code class="scheme"><SPAN>(struct set-box (new-value))
|
||
(struct box-state (value))</SPAN>
|
||
|
||
(spawn <SPAN>(field [current-value 0])</SPAN>
|
||
<SPAN><SPAN>(assert (box-state (current-value)))</SPAN></SPAN>
|
||
(on <SPAN>(message (set-box $new-value))</SPAN>
|
||
<SPAN>(current-value new-value)</SPAN>))
|
||
|
||
(spawn (on <SPAN>(asserted (box-state $v))</SPAN>
|
||
<SPAN>(send! (set-box (+ v 1)))</SPAN>))</code></pre></section>
|
||
<section data-transition="none" class="stage-3"><pre style="width: 65%;"><code class="scheme"><SPAN>(struct set-box (new-value))
|
||
(struct box-state (value))</SPAN>
|
||
|
||
(spawn <MARK>(field [current-value 0])</MARK>
|
||
<SPAN><SPAN>(assert (box-state (current-value)))</SPAN></SPAN>
|
||
(on <SPAN>(message (set-box $new-value))</SPAN>
|
||
<SPAN>(current-value new-value)</SPAN>))
|
||
|
||
(spawn (on <SPAN>(asserted (box-state $v))</SPAN>
|
||
<SPAN>(send! (set-box (+ v 1)))</SPAN>))</code></pre></section>
|
||
<section data-transition="none" class="stage-4"><pre style="width: 65%;"><code class="scheme"><SPAN>(struct set-box (new-value))
|
||
(struct box-state (value))</SPAN>
|
||
|
||
(spawn <SPAN>(field [current-value 0])</SPAN>
|
||
<MARK><SPAN>(assert (box-state (current-value)))</SPAN></MARK>
|
||
(on <SPAN>(message (set-box $new-value))</SPAN>
|
||
<SPAN>(current-value new-value)</SPAN>))
|
||
|
||
(spawn (on <SPAN>(asserted (box-state $v))</SPAN>
|
||
<SPAN>(send! (set-box (+ v 1)))</SPAN>))</code></pre></section>
|
||
<section data-transition="none" class="stage-5"><pre style="width: 65%;"><code class="scheme"><SPAN>(struct set-box (new-value))
|
||
(struct box-state (value))</SPAN>
|
||
|
||
(spawn <SPAN>(field [current-value 0])</SPAN>
|
||
<SPAN><SPAN>(assert (box-state (current-value)))</SPAN></SPAN>
|
||
(on <MARK>(message (set-box $new-value))</MARK>
|
||
<SPAN>(current-value new-value)</SPAN>))
|
||
|
||
(spawn (on <SPAN>(asserted (box-state $v))</SPAN>
|
||
<SPAN>(send! (set-box (+ v 1)))</SPAN>))</code></pre></section>
|
||
<section data-transition="none" class="stage-6"><pre style="width: 65%;"><code class="scheme"><SPAN>(struct set-box (new-value))
|
||
(struct box-state (value))</SPAN>
|
||
|
||
(spawn <SPAN>(field [current-value 0])</SPAN>
|
||
<SPAN><MARK>(assert (box-state (current-value)))</MARK></SPAN>
|
||
(on <SPAN>(message (set-box $new-value))</SPAN>
|
||
<MARK>(current-value new-value)</MARK>))
|
||
|
||
(spawn (on <SPAN>(asserted (box-state $v))</SPAN>
|
||
<SPAN>(send! (set-box (+ v 1)))</SPAN>))</code></pre></section>
|
||
<section data-transition="none" class="stage-7"><pre style="width: 65%;"><code class="scheme"><SPAN>(struct set-box (new-value))
|
||
(struct box-state (value))</SPAN>
|
||
|
||
(spawn <SPAN>(field [current-value 0])</SPAN>
|
||
<SPAN><SPAN>(assert (box-state (current-value)))</SPAN></SPAN>
|
||
(on <SPAN>(message (set-box $new-value))</SPAN>
|
||
<SPAN>(current-value new-value)</SPAN>))
|
||
|
||
(spawn (on <SPAN>(asserted (box-state $v))</SPAN>
|
||
<SPAN>(send! (set-box (+ v 1)))</SPAN>))</code></pre></section>
|
||
<section data-transition="none" class="stage-8"><pre style="width: 65%;"><code class="scheme"><SPAN>(struct set-box (new-value))
|
||
(struct box-state (value))</SPAN>
|
||
|
||
(spawn <SPAN>(field [current-value 0])</SPAN>
|
||
<SPAN><SPAN>(assert (box-state (current-value)))</SPAN></SPAN>
|
||
(on <SPAN>(message (set-box $new-value))</SPAN>
|
||
<SPAN>(current-value new-value)</SPAN>))
|
||
|
||
(spawn (on <MARK>(asserted (box-state $v))</MARK>
|
||
<SPAN>(send! (set-box (+ v 1)))</SPAN>))</code></pre></section>
|
||
<section data-transition="none" class="stage-9"><pre style="width: 65%;"><code class="scheme"><SPAN>(struct set-box (new-value))
|
||
(struct box-state (value))</SPAN>
|
||
|
||
(spawn <SPAN>(field [current-value 0])</SPAN>
|
||
<SPAN><SPAN>(assert (box-state (current-value)))</SPAN></SPAN>
|
||
(on <SPAN>(message (set-box $new-value))</SPAN>
|
||
<SPAN>(current-value new-value)</SPAN>))
|
||
|
||
(spawn (on <SPAN>(asserted (box-state $v))</SPAN>
|
||
<MARK>(send! (set-box (+ v 1)))</MARK>))</code></pre></section>
|
||
<section data-transition="none" class="stage-10"><pre style="width: 65%;"><code class="scheme"><SPAN>(struct set-box (new-value))
|
||
(struct box-state (value))</SPAN>
|
||
|
||
(spawn <SPAN>(field [current-value 0])</SPAN>
|
||
<SPAN><SPAN>(assert (box-state (current-value)))</SPAN></SPAN>
|
||
(on <SPAN>(message (set-box $new-value))</SPAN>
|
||
<SPAN>(current-value new-value)</SPAN>))
|
||
|
||
(spawn (on <SPAN>(asserted (box-state $v))</SPAN>
|
||
<SPAN>(send! (set-box (+ v 1)))</SPAN>))</code></pre></section></section></div>
|
||
</div><script src="reveal.js-3.6.0/lib/js/head.min.js"></script><script src="reveal.js-3.6.0/js/reveal.js"></script><script src="d3.v4.min.js"></script><script src="conversation-animation.js"></script><script>Reveal.initialize({"transition":"none","dependencies":[{"src":"reveal.js-3.6.0/plugin/markdown/marked.js"},{"src":"reveal.js-3.6.0/plugin/markdown/markdown.js"},{"src":"reveal.js-3.6.0/plugin/notes/notes.js"}],"controlsTutorial":false,"slideNumber":true,"history":true,"controls":false});</script></body></html>
|