Category Archives: Distributed Programming

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

Binaries in ABC (or UTF-8)

Awelon Bytecode (ABC) doesn’t have good direct support for binary data. Binaries are not uncommon: cipher texts, secure hash values, compressed visual or audio data, raw sensory data, and so on. Efficient storage and communication of binaries is a desirable … Continue reading

Posted in Distributed Programming, Language Design | 2 Comments

Code is Material

‘Code is data’ is a metaphor around which the Lisp communities (and REBOL, and others) have built programming languages. The metaphor is effective in these languages because code is presented and represented as a simple structure which may easily be … Continue reading

Posted in Distributed Programming, Language Design, Modularity, Open Systems Programming, UserInterface | 17 Comments

ABC Linking with Provider Independent Security

As I’ve mentioned in other posts, Awelon Bytecode (ABC) has a non-conventional approach to code reuse. A valid sequence of bytecode can be given a deterministic, cryptographically unique name – e.g. a secure hash. In ABC, the code to invoke … Continue reading

Posted in Distributed Programming, Language Design, Modularity, Open Systems Programming, Security | Tagged , , , | 5 Comments

Ubiquitous Programming with Pen and Paper

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

Stability without State

I understand `state` to be a summary of the past, maintained in the present, to inform the future. State is a powerful tool, and essential in many problems (such as writing this text). But state is often too powerful – … Continue reading

Posted in Concurrency, Distributed Programming, Modularity, Open Systems Programming, Reactive Demand Programming, Stability, State | 12 Comments

Signals in RDP

Reactive Demand Programming (RDP) describes behavior as signal transformers, in continuous time, with side-effects. For example, I might push a control signal to a camera (to influence pan, zoom, tilt, and focus), and the camera will provide a response signal … Continue reading

Posted in Concurrency, Distributed Programming, Language Design, Reactive Demand Programming, Types | 2 Comments

Dynamic Behaviors in RDP

RDP behaviors may be constructed and executed at runtime to extend a static program. Dynamic behaviors essential for many in-the-large RDP design patterns: pluggable extensibility – a service or application can publish dynamic behaviors into a shared registry, allowing subsystems … Continue reading

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

Data Model Independence

One of the most pervasive and stubborn challenges for open systems development is composing, fusing, adapting, integrating subsystems that use heterogeneous data models for similar tasks. By data model I mean how we group, share, describe, and update data in … Continue reading

Posted in Concurrency, Distributed Programming, Language Design, Live Programming, Modularity, Open Systems Programming, Reactive Demand Programming | Tagged , , , , | Leave a comment

Reject Remote Values

Haskell is a lazy programming language, in which a value is not fully computed before observed in a function; this easily allows for infinite structures, mutual recursion, and parallel processing. Oz/Mozart uses logic variables, which allow us to declare a … Continue reading

Posted in Distributed Programming, Language Design | 2 Comments