Category Archives: Open Systems Programming

Modular Manipulation of the Link-Time Environment

Posted on 2013 April 16 by

I’m in the process of hammering out a concrete design for Awelon, and my design efforts have taken me to some interesting places. My current application model looks like this: An Awelon application consists of a set of anonymous modules. … Continue reading →

Posted in Language Design, Modularity, Open Systems Programming, Security, State | 2 Comments

Why Not FFI

Posted on 2013 April 16 by

FFI – foreign function interface – is a common way for new languages to integrate with existing systems. But FFI is problematic in many ways. FFI represents ambient authority (the ability to ‘import’ authority to ad-hoc resources without a specific … Continue reading →

Posted in Language Design, Modularity, Open Systems Programming, Security | 3 Comments

Declarative State Machines

Posted on 2013 March 27 by

Lately, I’ve been wondering what state-machines would look like if specified for declarative systems. Traditional state machines are specified to receive a stream of events as input. Each event may shift the machine into a new state. The transitions are … Continue reading →

Posted in Concurrency, Open Systems Programming, State | Leave a comment

Ad-Hoc External State Models

Posted on 2013 March 23 by

Encapsulation, Accessibility, Security One of the main reasons we encapsulate state is to gain more control over how it updates. For example, take your traditional, imperative, mutable state variables that respond to get and put actions. We might use one … Continue reading →

Posted in Concurrency, Language Design, Modularity, Open Systems Programming, Reactive Demand Programming, State, Types | 1 Comment

Sirea RDP Progress Update: Demand Monitors are Working

Posted on 2013 January 14 by

My implementation of Reactive Demand Programming (RDP), Sirea, is gradually approaching a usable state. After vacation, I sat down and in just a couple programming sessions I got demand monitors into a working order. The implementation of demand monitors further … Continue reading →

Posted in Concurrency, Open Systems Programming, Reactive Demand Programming, State | 1 Comment

Ubiquitous Programming with Pen and Paper

Posted on 2012 October 26 by

Programming ideas strike at any time – while taking a walk, or standing in line. Meetings, for me, are a common location for programming ideas. A few slides or phrases catch my interest in an otherwise droll and predictable commentary. … Continue reading →

Posted in Distributed Programming, Language Design, Modularity, Open Systems Programming, Stability, State, UserInterface | Tagged , | 5 Comments

Local State is Poison

Posted on 2012 October 21 by

Up through early 2011, my visions of RDP still called for `new` (as in `new Object()` or `newIORef`). At that time, my vision of an RDP language was a two-layer model: the language would support a separate initialization step for … Continue reading →

Posted in Concurrency, Language Design, Modularity, Open Systems Programming, Security, State | 35 Comments

Stateless Stable Arts for Game Development

Posted on 2012 September 7 by

In the months since grasping the concept of stateless stable models, I regularly find scenarios where I think, “A stateless stable model would be useful here.” Unfortunately, I’ve not gotten around to implementing these models. (I still haven’t. I might … Continue reading →

Posted in Language Design, Live Programming, Modularity, Open Systems Programming, Stability, State, UserInterface | Leave a comment

Why Not Events

Posted on 2012 July 1 by

I’ve spent a lot of time arguing against event systems. I don’t argue because they’re bad; compared to batch processing or shared-state imperative concurrency, event systems (actors, vats, channels, etc.) solve many problems and are relatively easy to reason about. … Continue reading →

Posted in Concurrency, Language Design, Open Systems Programming, State | 14 Comments

Abandoning Commitment in HCI

Posted on 2012 May 20 by

Today’s applications and services are very committed to what they do for us. And I mean that in a bad way. When we send a message to a service, or call a procedure, or press a button, it is generally … Continue reading →

Posted in Open Systems Programming, Reactive Demand Programming, User Interface | Tagged , , , , , , , | 5 Comments