Category Archives: Reactive Demand Programming

Imperative Metaprogramming of a Declarative Program

A few people have been curious: Why am I modeling a multi stack environment in Awelon? Doesn’t this seem imperative? Isn’t the goal of relatively declarative models like reactive demand programming to get away from that? Traditionally, a dataflow model … Continue reading

Posted in Language Design, Reactive Demand Programming, UserInterface | Leave a comment

Awelon Virtual Machine

An ‘Awelon Virtual Machine’ (AVM) is a description of an RDP-based programming environment. This description includes types, partitions, and behavior primitives. It is a complete description, repeating even the ‘standard’ primitives like first and compose. Unlike a traditional VM, an … Continue reading

Posted in Grammars, Language Design, Modularity, Reactive Demand Programming, Types | Leave a comment

Ad-Hoc External State Models

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

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

Anticipation in RDP Reduced

Some time ago, I described anticipation in RDP. In that article, I envisioned a behavior intially called `anticipate`, that I eventually shortened to `bpeek`. For discrete-varying signals, it might be specialized to `bpeekL`. — observe a specific distance into a … Continue reading

Posted in Reactive Demand Programming, State | Leave a comment

Sirea RDP Progress Update: Demand Monitors are Working

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

Stone Soup Programming

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

RDP Progress Report

The current implementation of Reactive Demand Programming (RDP) is a Haskell library called Sirea, and is available on github. The readme file for Sirea serves as a decent introduction to RDP, though I am sure it is lacking in some … Continue reading

Posted in Language Design, Reactive Demand Programming | Leave a comment

Abandoning Commitment in HCI

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

Life With Objects

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