Tag Archives: value

On Separating Values and Effects

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

Posted in Uncategorized | Also tagged , , , , , , , , , , , , , , | Leave a comment

Futures and Capabilities

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

Posted in Uncategorized | Also tagged , , , , , , , , , , , , , , , | 2 Comments

Fexpr the Ultimate Lambda

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

Posted in Uncategorized | Also tagged , , , , , , , , , , , , , | 7 Comments

Finger Tree: A Functional Value Object

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

Posted in Uncategorized | Also tagged , , , , , , | 8 Comments

Parsing Expression Grammars, part 2

It’s usually not enough to simply recognize patterns in an input stream. Soon we will want to take action based on what we recognize. In order to facilitate this, we will begin creating semantic values from the input tokens and trigger semantic actions when certain patterns are recognized. In part 1 of this series we […]

Posted in Uncategorized | Also tagged , , , , , , , , | 2 Comments

Evaluating Expressions, part 6 – Actor Primitives

In part 6 of our series implementing programming language constructs with actors, we explore meta-circular definition of imperative actor primitives. We have now moved beyond expressions which yield values, and focus on statements which cause effects. The constructs explored here are the heart of any actor-based system. In order to support actor primitive statements, our […]

Posted in Uncategorized | Also tagged , , , , , , , , , , | 5 Comments

Evaluating Expressions, part 5 – Recursion

Some language environments provide an interactive interface called a Read-Eval-Print-Loop (abbreviated REPL). One key characteristic of a REPL is the ability to incrementally define, extend and re-define your environment. This is particularly challenging in a pure-functional context, such as the evaluator we have developed so far. Modularity and incremental development seems to imply the need […]

Posted in Uncategorized | Also tagged , , , , , , , , , , | 3 Comments

Evaluating Expressions, part 4 – Pattern Equations

In part 4 of our series implementing programming language constructs with actors, we extend our pattern matching behaviors to support pattern equations. These are true equations that express relationships between patterns. They form the basis for introducing LET and IF expressions. The grammar for our extended language is shown below. Changes from part 3 are […]

Posted in Uncategorized | Also tagged , , , , , , , , , | 6 Comments

Evaluating Expressions, part 3 – Pairs and Parallelism

In part 3 of our series implementing programming language constructs with actors, we explore parallel evaluation of sub-expressions and introduce pairs.  Pairs allow the construction of tuples, generalizing structured multi-part patterns and values. In order to support pair expressions and patterns, we’ve refactored the grammar from part 2 to separate out literal constants expressions and […]

Posted in Uncategorized | Also tagged , , , , , , , , | 5 Comments

Evaluating Expressions, part 2 – Conditional Special Form

We continue exploring actor implementation of programming language constructs by adding a special form for conditional expressions. This will not increase the expressive power of the language. In part 1 we implemented a Turing-complete pure untyped lambda calculus. Now we add direct efficient support for conditional expressions and introduce basic pattern matching. Changes from the […]

Posted in Uncategorized | Also tagged , , , , , | 3 Comments

Evaluating Expressions, part 1 – Core Lambda Calculus

One of the best ways to understand programming language constructs is to implement them. We will begin by implementing a simple, yet Turing-complete, functional expression language.  In subsequent articles, we will extend this language with additional features.  For now we will focus on just the “untyped” lambda calculus, augmented with constants. The grammar for our expression […]

Posted in Uncategorized | Also tagged , , , , | 5 Comments

Actors in Clojure — Why Not?

In his article about state management in Clojure, Rich Hickey discusses his reasons for choosing not to use the Erlang-style actor model. While Erlang has made some implementation choices that can lead to problems, the problems are not intrinsic to the Actor Model. As the actor implementation with the longest history of success, Erlang naturally represents […]

Posted in Uncategorized | Also tagged , , , , , , , , , , | 14 Comments