Category Archives: Modularity

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 | 3 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

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

Progress Report: Loops and Restarts in Sirea

Posted on 2013 March 12 by

I’ve been working on Sirea quite a bit in the last few months, albeit making less progress than I had hoped. Mostly, I’ve been running in circles. In Reactive Demand Programming, all loops are indirect, via a shared external resource … Continue reading →

Posted in Modularity, Reactive Demand Programming, Stability | Leave a 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

Stone Soup Programming

Posted on 2012 September 12 by

Stone soup programming is meant to evoke an image of throwing software components into a pot – in no particular order, and paying little attention to the ingredients – and the result being a nice application. The glue code between … Continue reading →

Posted in Language Design, Live Programming, Modularity, Reactive Demand Programming, Stability, Types | 6 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

Life With Objects

Posted on 2012 May 1 by

This is a wordy response to Chris Turner’s Life Without Objects. Many object models compose poorly. There are no generic methods to combine two objects into a meaningful third. Rather than composition, we get a Cartesian product of specializations (e.g. … Continue reading →

Posted in Language Design, Modularity, Open Systems Programming, Reactive Demand Programming | 5 Comments

Windowed Memoization?

Posted on 2012 April 25 by

I assume you already know what memoization is and why we might want to use it. In the context of reactive computations, memoization can improve performance a great deal, avoiding recalculation of data that has not changed. Most reactive paradigms, … Continue reading →

Posted in Language Design, Live Programming, Modularity, State | 8 Comments