Archive for Uncategorized

Serializers Revisited

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

One of the earliest concepts explored on this blog was the Serializer, which is a mechanism for providing exclusive access to a group of actors [1]. More recently, Carl Hewitt has referred to an extended version of this mechanism (with holes) as “Swiss Cheese”. Here we present a simple version that serializes requests on a […]

Continue reading » No comments

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 » 4 Comments

Towards a Universal Implementation of Unforgeable Actor Addresses

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

[It is my pleasure to welcome my colleague and collaborator, Tristan Slominski, as a guest-blogger —Dale] 2017-02-07 EDIT: A previous version of this article used the term Domain instead of Realm. In the popular implementations of the Actor Model, actor addresses are usually globally available to any other actor desiring to discover them. However, in […]

Continue reading » 2 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