Category Archives: Concurrency

Reactive Process Networks

Kahn Process Networks are a very nice sweet spot for functional purity and concurrency, and are widely applicable. I’ve recently considered them as a viable alternative to monadic effects models. However, KPNs are missing an important feature: the ability to … Continue reading

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

KPNs as an Effects Model

In this article, I motivate a variant of Kahn Process Networks (KPNs) with bounded channels as a better – more efficient, scalable, composable, securable, serializable, comprehensible, and debuggable – approach to modeling effectful application behavior. Especially in context of purely … Continue reading

Posted in Concurrency, Language Design, Modularity, Open Systems Programming, State | Tagged , , , | 8 Comments

Pure Process Parallelism

For purely functional programming, Haskell-style par/seq parallelism is has a simple API and is flexible. But it assumes you have lightweight threads and scheduling. Unfortunately, par/seq does not work nicely if the overhead for forking a thread or communication between … Continue reading

Posted in Concurrency, Language Design | Tagged , , , , | Leave a comment

Abstract Awelon Virtual Machines

I’m still working towards Wikilon, a wiki-based development environment and initial software platform for the Awelon project. The design is still fluid, and has taken me in some interesting and unconventional directions on the ‘development environment’ side. On the ‘software … Continue reading

Posted in Concurrency, Modularity, Open Systems Programming, Security, State | 10 Comments

VCache, an Acid-State Killer

Haskell has a convenient package called acid-state, which enables a Haskell value to be utilized as a database, essentially via the command pattern: updates are logged, and programmers can perform the occasional checkpoint; on restart, the checkpoint is loaded and … Continue reading

Posted in Concurrency, Modularity, State | 8 Comments

Multi Stack Environment in Awelon

Last post, I took things to an extreme. Which is a good thing. Extremism tells us where the limits are. After we know the limits, we can seek balance. There is a simple problem with the tree-zipper environment: It is … Continue reading

Posted in Concurrency, Language Design, Modularity, Types, UserInterface | 3 Comments

Declarative State Machines

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

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

Local State is Poison

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