<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0"
	xmlns:content="http://purl.org/rss/1.0/modules/content/"
	xmlns:wfw="http://wellformedweb.org/CommentAPI/"
	xmlns:dc="http://purl.org/dc/elements/1.1/"
	xmlns:atom="http://www.w3.org/2005/Atom"
	xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
	xmlns:slash="http://purl.org/rss/1.0/modules/slash/"
	>

<channel>
	<title>It&#039;s Actors All The Way Down</title>
	<atom:link href="http://www.dalnefre.com/wp/feed/" rel="self" type="application/rss+xml" />
	<link>http://www.dalnefre.com/wp</link>
	<description>Exploring the design and implementation of reliable, scalable, massively-concurrent computer systems</description>
	<lastBuildDate>Fri, 17 Feb 2012 04:14:12 +0000</lastBuildDate>
	<language>en</language>
	<sy:updatePeriod>hourly</sy:updatePeriod>
	<sy:updateFrequency>1</sy:updateFrequency>
	
		<item>
		<title>Implementing Actors in Kernel</title>
		<link>http://www.dalnefre.com/wp/2012/02/implementing-actors-in-kernel/</link>
		<comments>http://www.dalnefre.com/wp/2012/02/implementing-actors-in-kernel/#comments</comments>
		<pubDate>Fri, 17 Feb 2012 04:12:36 +0000</pubDate>
		<dc:creator>Dale Schumacher</dc:creator>
				<category><![CDATA[Uncategorized]]></category>
		<category><![CDATA[actor]]></category>
		<category><![CDATA[asynchronous]]></category>
		<category><![CDATA[concurrency]]></category>
		<category><![CDATA[evaluation]]></category>
		<category><![CDATA[event]]></category>
		<category><![CDATA[event-loop]]></category>
		<category><![CDATA[Kernel]]></category>
		<category><![CDATA[lambda-calculus]]></category>
		<category><![CDATA[message-passing]]></category>
		<category><![CDATA[Scheme]]></category>
		<category><![CDATA[synchronization]]></category>
		<category><![CDATA[vau-calculus]]></category>

		<guid isPermaLink="false">http://www.dalnefre.com/wp/?p=138</guid>
		<description><![CDATA[Now is the time we come full-circle in our exploration of Kernel/Scheme/LISP and show how Actors can be implemented on this foundation. This should dispel the notion that Actors are just functions/procedures. Sure, when an Actor receives a message you could say that the message is &#8220;applied&#8221; to the Actor&#8217;s current behavior. In that sense, [...]]]></description>
		<wfw:commentRss>http://www.dalnefre.com/wp/2012/02/implementing-actors-in-kernel/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Mutable Objects in Kernel</title>
		<link>http://www.dalnefre.com/wp/2012/01/mutable-objects-in-kernel/</link>
		<comments>http://www.dalnefre.com/wp/2012/01/mutable-objects-in-kernel/#comments</comments>
		<pubDate>Fri, 20 Jan 2012 02:50:53 +0000</pubDate>
		<dc:creator>Dale Schumacher</dc:creator>
				<category><![CDATA[Uncategorized]]></category>
		<category><![CDATA[extensibility]]></category>
		<category><![CDATA[functional]]></category>
		<category><![CDATA[Kernel]]></category>
		<category><![CDATA[object-oriented]]></category>
		<category><![CDATA[queue]]></category>
		<category><![CDATA[vau-calculus]]></category>

		<guid isPermaLink="false">http://www.dalnefre.com/wp/?p=137</guid>
		<description><![CDATA[One important difference between Kernel and traditional LISP/Scheme is Kernel&#8217;s pervasive use of encapsulated types [1]. There is a clear distinction in Kernel between decomposable structures and opaque objects. Encapsulated types are a significant contributor toward smooth extensibility. They allow the definition of objects, and operations on those object, that are indistinguishable from primitives. We [...]]]></description>
		<wfw:commentRss>http://www.dalnefre.com/wp/2012/01/mutable-objects-in-kernel/feed/</wfw:commentRss>
		<slash:comments>8</slash:comments>
		</item>
		<item>
		<title>Semantic Extensibility with Vau</title>
		<link>http://www.dalnefre.com/wp/2011/12/semantic-extensibility-with-vau/</link>
		<comments>http://www.dalnefre.com/wp/2011/12/semantic-extensibility-with-vau/#comments</comments>
		<pubDate>Sun, 18 Dec 2011 16:33:24 +0000</pubDate>
		<dc:creator>Dale Schumacher</dc:creator>
				<category><![CDATA[Uncategorized]]></category>
		<category><![CDATA[actor]]></category>
		<category><![CDATA[evaluation]]></category>
		<category><![CDATA[extensibility]]></category>
		<category><![CDATA[functional]]></category>
		<category><![CDATA[Kernel]]></category>
		<category><![CDATA[lambda-calculus]]></category>
		<category><![CDATA[language]]></category>
		<category><![CDATA[LISP]]></category>
		<category><![CDATA[pair]]></category>
		<category><![CDATA[queue]]></category>
		<category><![CDATA[Scheme]]></category>
		<category><![CDATA[vau-calculus]]></category>

		<guid isPermaLink="false">http://www.dalnefre.com/wp/?p=133</guid>
		<description><![CDATA[John Shutt has reformulated the foundations of LISP/Scheme [1]. Observing that Lambda is a primitive applicative constructor, he proposes Vau as a primitve operative constructor instead. This changes our focus from implicit evaluation to explicit evaluation. Applicatives evaluate their operands before evaluating the combination. Operatives act directly on their (unevaluated) operands, possibly evaluating them selectively. [...]]]></description>
		<wfw:commentRss>http://www.dalnefre.com/wp/2011/12/semantic-extensibility-with-vau/feed/</wfw:commentRss>
		<slash:comments>5</slash:comments>
		</item>
		<item>
		<title>Fexpr the Ultimate Lambda</title>
		<link>http://www.dalnefre.com/wp/2011/11/fexpr-the-ultimate-lambda/</link>
		<comments>http://www.dalnefre.com/wp/2011/11/fexpr-the-ultimate-lambda/#comments</comments>
		<pubDate>Fri, 25 Nov 2011 17:32:25 +0000</pubDate>
		<dc:creator>Dale Schumacher</dc:creator>
				<category><![CDATA[Uncategorized]]></category>
		<category><![CDATA[actor]]></category>
		<category><![CDATA[evaluation]]></category>
		<category><![CDATA[extensibility]]></category>
		<category><![CDATA[functional]]></category>
		<category><![CDATA[Kernel]]></category>
		<category><![CDATA[lambda-calculus]]></category>
		<category><![CDATA[language]]></category>
		<category><![CDATA[LISP]]></category>
		<category><![CDATA[object-oriented]]></category>
		<category><![CDATA[pair]]></category>
		<category><![CDATA[pattern-matching]]></category>
		<category><![CDATA[recursion]]></category>
		<category><![CDATA[Scheme]]></category>
		<category><![CDATA[value]]></category>
		<category><![CDATA[vau-calculus]]></category>

		<guid isPermaLink="false">http://www.dalnefre.com/wp/?p=129</guid>
		<description><![CDATA[This article is dedicated to the memory of John McCarthy (1927-2011) We are constantly on a quest for the elegant combination of simplicity and expressiveness in computer languages&#x2014;what Alan Kay calls the &#8220;Maxwell’s Equations of Software&#8220;. An important early milestone was John McCarthy&#8217;s LISP [1]. The evolution of these ideas and the thinking behind them [...]]]></description>
		<wfw:commentRss>http://www.dalnefre.com/wp/2011/11/fexpr-the-ultimate-lambda/feed/</wfw:commentRss>
		<slash:comments>4</slash:comments>
		</item>
		<item>
		<title>High Availability for Mutable Shared State</title>
		<link>http://www.dalnefre.com/wp/2011/11/high-availability-for-mutable-shared-state/</link>
		<comments>http://www.dalnefre.com/wp/2011/11/high-availability-for-mutable-shared-state/#comments</comments>
		<pubDate>Mon, 07 Nov 2011 13:14:26 +0000</pubDate>
		<dc:creator>Dale Schumacher</dc:creator>
				<category><![CDATA[Uncategorized]]></category>
		<category><![CDATA[actor]]></category>
		<category><![CDATA[asynchronous]]></category>
		<category><![CDATA[availability]]></category>
		<category><![CDATA[blocking]]></category>
		<category><![CDATA[consistency]]></category>
		<category><![CDATA[queue]]></category>
		<category><![CDATA[scalability]]></category>
		<category><![CDATA[serializer]]></category>
		<category><![CDATA[starvation]]></category>

		<guid isPermaLink="false">http://www.dalnefre.com/wp/?p=127</guid>
		<description><![CDATA[Mutable shared state is the root of all evil in concurrent systems. The history of concurrent computation is a basically the story of approaches to managing mutable shared state. The thread model, which has long held the dominant position, leads to intractable complexity [1]. The actor model captures state in the behavior of an actor. [...]]]></description>
		<wfw:commentRss>http://www.dalnefre.com/wp/2011/11/high-availability-for-mutable-shared-state/feed/</wfw:commentRss>
		<slash:comments>2</slash:comments>
		</item>
		<item>
		<title>Erlang-style Mailboxes</title>
		<link>http://www.dalnefre.com/wp/2011/10/erlang-style-mailboxes/</link>
		<comments>http://www.dalnefre.com/wp/2011/10/erlang-style-mailboxes/#comments</comments>
		<pubDate>Mon, 17 Oct 2011 13:02:21 +0000</pubDate>
		<dc:creator>Dale Schumacher</dc:creator>
				<category><![CDATA[Uncategorized]]></category>
		<category><![CDATA[actor]]></category>
		<category><![CDATA[asynchronous]]></category>
		<category><![CDATA[blocking]]></category>
		<category><![CDATA[Erlang]]></category>
		<category><![CDATA[message-passing]]></category>
		<category><![CDATA[queue]]></category>
		<category><![CDATA[synchronization]]></category>

		<guid isPermaLink="false">http://www.dalnefre.com/wp/?p=122</guid>
		<description><![CDATA[One significant difference between message-passing in Erlang and the pure Actor Model is the Erlang concept of mailboxes. Actors don&#8217;t have mailboxes, at least not in the sense that they can be queried. Messages simply arrive at some non-deterministic time after they are asynchronously sent, invoking the current behavior of the actor. However, in Erlang, [...]]]></description>
		<wfw:commentRss>http://www.dalnefre.com/wp/2011/10/erlang-style-mailboxes/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Finger Tree: A Functional Value Object</title>
		<link>http://www.dalnefre.com/wp/2011/09/finger-tree-a-functional-value-object/</link>
		<comments>http://www.dalnefre.com/wp/2011/09/finger-tree-a-functional-value-object/#comments</comments>
		<pubDate>Tue, 13 Sep 2011 13:40:28 +0000</pubDate>
		<dc:creator>Dale Schumacher</dc:creator>
				<category><![CDATA[Uncategorized]]></category>
		<category><![CDATA[deque]]></category>
		<category><![CDATA[functional]]></category>
		<category><![CDATA[object-oriented]]></category>
		<category><![CDATA[queue]]></category>
		<category><![CDATA[sequence]]></category>
		<category><![CDATA[stack]]></category>
		<category><![CDATA[streams]]></category>
		<category><![CDATA[value]]></category>

		<guid isPermaLink="false">http://www.dalnefre.com/wp/?p=106</guid>
		<description><![CDATA[A Finger Tree is a data-structure that supports amortized O(1) additional and removal of elements from either end [1]. It also can support a large number of common sequence operations, including concatenation, very efficiently. Our implementation is based on the Hinze-Paterson structure [2], simplified for use as a Deque. It is possible to implement a [...]]]></description>
		<wfw:commentRss>http://www.dalnefre.com/wp/2011/09/finger-tree-a-functional-value-object/feed/</wfw:commentRss>
		<slash:comments>8</slash:comments>
		</item>
		<item>
		<title>In-Order Message Delivery</title>
		<link>http://www.dalnefre.com/wp/2011/07/in-order-message-delivery/</link>
		<comments>http://www.dalnefre.com/wp/2011/07/in-order-message-delivery/#comments</comments>
		<pubDate>Fri, 15 Jul 2011 12:56:06 +0000</pubDate>
		<dc:creator>Dale Schumacher</dc:creator>
				<category><![CDATA[Uncategorized]]></category>
		<category><![CDATA[actor]]></category>
		<category><![CDATA[channel]]></category>
		<category><![CDATA[composition]]></category>
		<category><![CDATA[data-flow]]></category>
		<category><![CDATA[distribution]]></category>
		<category><![CDATA[Erlang]]></category>
		<category><![CDATA[message-passing]]></category>

		<guid isPermaLink="false">http://www.dalnefre.com/wp/?p=105</guid>
		<description><![CDATA[The Actor Model explicitly avoids placing constraints on message delivery order beyond causality [1]. Messages may not be delivered before the message which caused them to be sent. In other words, time can&#8217;t flow backward. Beyond that, messages arrive in a non-deterministic order. This can sometimes have surprising consequences. Two messages sent in sequence from [...]]]></description>
		<wfw:commentRss>http://www.dalnefre.com/wp/2011/07/in-order-message-delivery/feed/</wfw:commentRss>
		<slash:comments>1</slash:comments>
		</item>
		<item>
		<title>Circuit Breaker Stability Pattern</title>
		<link>http://www.dalnefre.com/wp/2011/06/circuit-breaker-stability-pattern/</link>
		<comments>http://www.dalnefre.com/wp/2011/06/circuit-breaker-stability-pattern/#comments</comments>
		<pubDate>Mon, 13 Jun 2011 15:35:20 +0000</pubDate>
		<dc:creator>Dale Schumacher</dc:creator>
				<category><![CDATA[Uncategorized]]></category>
		<category><![CDATA[actor]]></category>
		<category><![CDATA[circuit-breaker]]></category>
		<category><![CDATA[distribution]]></category>
		<category><![CDATA[patterns]]></category>
		<category><![CDATA[stability]]></category>
		<category><![CDATA[state-machine]]></category>

		<guid isPermaLink="false">http://www.dalnefre.com/wp/?p=101</guid>
		<description><![CDATA[In a loosely-coupled system connected with asynchronous messages, a flood of client requests can exceed the capacity of a service. When this happens, we would prefer that the service respond with an indication of the overloaded condition, rather than making us wait for service we may never receive. The Twitter &#8220;fail whale&#8221; is an example. [...]]]></description>
		<wfw:commentRss>http://www.dalnefre.com/wp/2011/06/circuit-breaker-stability-pattern/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Actors Make Better Observers</title>
		<link>http://www.dalnefre.com/wp/2011/05/actors-make-better-observers/</link>
		<comments>http://www.dalnefre.com/wp/2011/05/actors-make-better-observers/#comments</comments>
		<pubDate>Sun, 22 May 2011 12:00:49 +0000</pubDate>
		<dc:creator>Dale Schumacher</dc:creator>
				<category><![CDATA[Uncategorized]]></category>
		<category><![CDATA[actor]]></category>
		<category><![CDATA[asynchronous]]></category>
		<category><![CDATA[blocking]]></category>
		<category><![CDATA[distribution]]></category>
		<category><![CDATA[JavaScript]]></category>
		<category><![CDATA[listener]]></category>
		<category><![CDATA[message-passing]]></category>
		<category><![CDATA[observer]]></category>
		<category><![CDATA[patterns]]></category>
		<category><![CDATA[pub-sub]]></category>
		<category><![CDATA[synchronous]]></category>

		<guid isPermaLink="false">http://www.dalnefre.com/wp/?p=98</guid>
		<description><![CDATA[The Observer pattern causes temporal coupling in systems with synchronous message passing. This can lead to failure in Object-Oriented systems. Asynchronous messaging avoids the pitfalls. Actor-based implementations more accurately realize the original intent of the pattern. The intent of the Observer pattern is to &#8220;define a one-to-many dependency between objects so that when one object [...]]]></description>
		<wfw:commentRss>http://www.dalnefre.com/wp/2011/05/actors-make-better-observers/feed/</wfw:commentRss>
		<slash:comments>2</slash:comments>
		</item>
	</channel>
</rss>

<!-- Dynamic page generated in 0.934 seconds. -->
<!-- Cached page generated by WP-Super-Cache on 2012-02-22 22:51:16 -->

