Author Archive

Requirements for an Actor Programming Language

Tags: , , , ,

The Actor Model of computation does not define a programming language. It defines a semantic model. This post attempts to describe the minimal features required in any programming language that implements the Actor Model. Actor Primitives A programming language for actors must begin with support for the three primitive actor operations: Create a new actor […]

Continue reading » No comments

Computer Security Breaches Are Preventable

Tags: , , , ,

Security system breaches resulting in exposure of large quantities of sensitive information have become increasingly common. As data-hungry enterprises aggregate larger and larger caches of sensitive information, the damage from the inevitable breaches becomes more significant and far-reaching. Is there something fundamentally wrong with the design of our security systems? Can these risks be mitigated? […]

Continue reading » 1 Comment

Distributed Security

Tags: , , , , , , , , , , , , , , , ,

Within a single address-space, the capability-security properties of actor references are guaranteed by the actor run-time. Memory-safe implementations of actor languages ensure that actor references cannot be forged. Having a reference to an actor means you have permission to send it a message. A single machine may host multiple independent actor address-spaces, each of which […]

Continue reading » 1 Comment

“Same Fringe” Revisited

Tags: , , , , , , , , , ,

The fringe of a binary tree is simply the sequence of leaves reading from left to right [1]. Comparing the fringe of two binary trees to see if they are the same has been described as the simplest problem that requires multiprocessing or coroutines to easily solve [2]. The challenge is to stop the comparison […]

Continue reading » 1 Comment

On Separating Values and Effects

Tags: , , , , , , , , , , , , , , , ,

Computability Theory is the foundation for computer software development. Our programming languages embody the techniques and models described by various theories of computation [1]. The Turing Machine is the canonical example of the Imperative Model [2]. Lambda Calculus is the canonical example of the Functional Model [3]. Kleene’s Church–Turing Thesis asserts the equivalence of these […]

Continue reading » No comments

Implementing Actors in JavaScript

Tags: , , , , , ,

JavaScript does not exactly have an ideal semantic model for implementing Actors. Execution is single-threaded and sequential. Most objects are mutable by default. However, it has the advantage of being the most available and widely used computer language, so it seems worthwhile to show how actors can be used in this environment. Asynchronous Programming JavaScript […]

Continue reading » 3 Comments

Debugging Actor Systems

Tags: , , , , , , , , , ,

Software development is a defect injection process. With every line of code we write, we have a chance of introducing unintended behavior into the system. This chance increases with conceptual complexity. The more difficult a system is to understand, the greater our chance of introducing defects. In his 1980 Turing Award lecture, Tony Hoare said […]

Continue reading » 1 Comment

Producer/Consumer Rate-Matching

Tags: , , , , , , , , , , , , , , ,

Flow control is a critical feature in a network of asynchronous communicating processes. Our fanciful exploration of a yak-shaving barber’s shop provided us with patterns we can apply to more general problems. The bounded-buffer mechanism is a generalization of our barber’s waiting room. It mediates between producers and consumers, matching the rate of production with […]

Continue reading » No comments

“Sleeping Barber” in Humus

Tags: , , , , , , , , ,

The “Sleeping Barber” problem is another classic concurrency example. As with our previous discussion of “Dining Philosophers”, actors allow a novel approaching to solving this problem. We will adjust a few of the details to enhance the metaphor and have a bit of fun with it. Our metaphorical barber provides yak shaving services. Yaks arrive […]

Continue reading » 5 Comments

Futures and Capabilities

Tags: , , , , , , , , , , , , , , , ,

In the Actor Model, concurrency is the default. Sequencing must by arranged explicitly. An important case of sequencing occurs when there is a data dependency between different parts of a system. One part produces a value that another part needs to perform its function. One mechanism for sequencing data-dependent operations is to create a Future. […]

Continue reading » 2 Comments

Implementing Actors in Kernel

Tags: , , , , , , , , , , ,

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 “applied” to the Actor’s current behavior. In that sense, […]

Continue reading » No comments

Mutable Objects in Kernel

Tags: , , , , ,

One important difference between Kernel and traditional LISP/Scheme is Kernel’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 […]

Continue reading » 8 Comments

Semantic Extensibility with Vau

Tags: , , , , , , , , , , ,

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. […]

Continue reading » 5 Comments

Fexpr the Ultimate Lambda

Tags: , , , , , , , , , , , , , ,

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—what Alan Kay calls the “Maxwell’s Equations of Software“. An important early milestone was John McCarthy’s LISP [1] (The evolution of these ideas and the thinking behind them […]

Continue reading » 7 Comments

High Availability for Mutable Shared State

Tags: , , , , , , , ,

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. […]

Continue reading » 2 Comments

Erlang-style Mailboxes

Tags: , , , , , ,

One significant difference between message-passing in Erlang and the pure Actor Model is the Erlang concept of mailboxes. Actors don’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, […]

Continue reading » No comments

Finger Tree: A Functional Value Object

Tags: , , , , , , ,

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 […]

Continue reading » 8 Comments

In-Order Message Delivery

Tags: , , , , , ,

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’t flow backward. Beyond that, messages arrive in a non-deterministic order. This can sometimes have surprising consequences. Two messages sent in sequence from […]

Continue reading » 1 Comment

Circuit Breaker Stability Pattern

Tags: , , , , ,

[Update 2014-02-02: I’ve posted a video showing a visualization of this pattern at http://www.youtube.com/watch?v=WEXh1WoppMU] 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 […]

Continue reading » No comments

Actors Make Better Observers

Tags: , , , , , , , , , ,

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 “define a one-to-many dependency between objects so that when one object […]

Continue reading » 3 Comments