Author Archives: dmbarbour

Ubiquitous Programming with Pen and Paper

Posted on 2012 October 26

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

Goodbye, Twitter

Posted on 2012 October 25

Goodbye, Twitter. Our brief relationship started only six months ago, with the positive response to my “life with objects” post. But, before I knew it, you were draining a considerable fraction of my precious time and energy right out of … Continue reading →

Posted in Human | 4 Comments

Local State is Poison

Posted on 2012 October 21

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

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

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

RDP Progress Report

Posted on 2012 September 4

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

Exponential Decay of History

Posted on 2012 August 20

There are many problems for which it is useful to keep a history. A few examples of such problems: keep history of control-flow in an application for debugging purposes keep history of updates to a document for undo purposes keep … Continue reading →

Posted in Language Design, Stability, State, Types, User Interface | 3 Comments

Natural Programming Language

Posted on 2012 August 1

A recent essay about why natural language isn’t computer code has been making a few rounds through the PL community. It seems to celebrate the precision required in computer languages, the differences between coders and writers. The article concludes: Fundamentally, … Continue reading →

Posted in Language Design, Live Programming, UserInterface | Tagged , , | 4 Comments

Unlimited Detail for Large Animated Worlds

Posted on 2012 July 18

A group called Euclideon from Australia has made extraordinary claims about Unlimited Detail technology – ability to achieve much more detail in a world as you zoom in or out by representing structures in terms of atoms of arbitrary precision. … Continue reading →

Posted in Concurrency, Grammars, User Interface, UserInterface | Tagged , , | 2 Comments

Why Not Events

Posted on 2012 July 1

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