On December 20, just in time for the Mayan apocalypse, I thought of an approach to computer programming that unites my meaning-preserving modularity, some of David Barbour‘s RDP vision, and my own philosophical worldview.
I’m calling it Reactive Knowledge Networking. It takes the philosophical idea that a person does nothing with the world except observation and action, and it uses that idea to facilitate people’s communication with each other, with minimal (if any) computer configuration bureaucracy along the way. Its network structure is very similar to RDP, and it uses meaning-preserving modularity to encode the partial knowledge a person has observed.
My philosophy and concern
I do a lot of armchair reasoning without much understanding of empirical science or how other people think. I will make sweeping statements about reality and personhood here, but I hope you readers don’t take my claims for granted.
I’ve spent some time thinking about ethics recently. I’m concerned that future developments in computer science will lead to all-new expanses of controversial ethical scenarios, leading to bitter conflicts that resist diplomatic resolution. But I believe we can counteract this by focusing on technology that improves our societal mechanisms for forming consensus, and by engineering our computing infrastructure to correspond as closely as possible with our existing ethical expectations.
As those expectations go, I think a wide spectrum of our struggles and ambitions can be classified as efforts to approximate our lives to a certain spiritual formal model: A person would like to understand all of their conscious experience in terms of a mostly self-evident line of reasoning whose only leap of faith is evidenced by their own inexplicable sensation of free will. That is, they would like to fully understand the rules of the game as well as all of the ways that the rules give way to players… and the person themselves must be part of the player-space, not part of the rule-space.
There are good reasons we treat other humans as parts of the player-space, even when noble ideals or instinct are out of the equation. One human can’t fully predict or control how another human behaves, and yet humans are great assets in each other’s lives, so they must accept each other’s unpredictableness. Indeed, humans actively protect their own unpredictableness in the name of their freedom and privacy.
Suppose we develop a stateful, self-maintaining computer system that resists reverse-engineering and has a good enough UI. Then it too may be stubbornly unpredictable and yet too useful to dismiss. If and when our society takes computational people under its wing, it will no longer be possible for us to make the simplifying ethical assumptions that we are all mortal, all acting independently, all possible to isolate within a physical space of practical construction, all susceptible to the same advertising mind games, etc.
I have no malice toward computational people themselves, nor against the researchers and practitioners whose ambitions might give birth to them, but I encourage people to practice safe techs, so that we can best prepare a peaceful stage for revolutionary technologies as they come along.
Background on RDP
David Barbour is pursuing a computational model called Reactive Demand Programming, or RDP for short. An RDP behavior acts on a time-varying input signal and transforms it into a time-varying output signal, emphasizing continuous transformations and side effects. One of David’s goals is stability: If the system somehow misbehaves for a short period of time (e.g. network disruption or user error), it should have very little impact on future behavior. Whereas most languages deal with state by using instantaneous change events, those zero-duration concepts would ideally have zero effect in RDP. David intends RDP to be useful for almost any kind of programming, but it’s particularly generalized to encompass the domain of secure orchestration of resources on open networks, where the Internet of today is a rat’s nest of incompatible frameworks, unnecessary complication, and even poor metaphors for end users.
Here are some points about RDP that will become relevant as I discuss my own model:
In RDP, all state is external to every behavior, regardless of whether it’s the state of data storage or (more obviously) the physical state of a sensor or actuator. This should improve “components that might provide persistence, extensions, or support transition of state during upgrade.”
In RDP, behaviors are first-class, much like the first-class functions programmers are used to. An input or output signal can contain an encapsulated reference to a (time-varying) behavior, which can be called dynamically. This should make it easy for programmers to specify fine-grained interaction protocols using techniques from object-capability security. (Note: David’s current implementation of RDP is a Haskell EDSL for expressing concurrent semantics in non-distributed, closed-system computation. Secure encapsulation of dynamic behaviors is on the roadmap, but it’s a feature that may not exist for a while.)
Reactive Knowledge Networking
RDP makes state external. In the context of my ethical viewpoint, I think making state external implies making emergent personhood external, which in turn guarantees that all programs live wholly in the rule-space, not the player-space. However, just because emergent personhood is external to one language’s semantic model doesn’t mean it’s absent in the overall practice of using that language; it might just be relegated to a separate component in the workbench. We might delay the emergence further if we center the computational model around the idea that people as we know them are the only external interface our programs need.
Earlier, I outlined a particular formal model our society seems to be approximating: The world’s rules are clearly laid out, and its presence of free will is fully classified. However, that’s just an ideal we approach over time. At any given time, a human has only partial information on hand.
If we assume (dubiously) that a person can truly know, rather than merely believe, then I’ve actually already been considering a practical way to represent what the person knows. True knowledge is monotonic; its usefulness is never undermined by the introduction of other knowledge. And the space of all possible knowledge is independent from the particular portion someone holds at a given time. These are already precisely the properties I aim to ensure with my meaning-preserving modularity techniques.
This takes care of letting people have observations, but what can they do with that input? Since potentially we have nothing but people at the edges of this model, and the model itself has no state, the only action worth taking upon our model is communication to another person. This folds nicely into the knowledge level: A receiving a communication might as well understand the incoming observations as part of their overall knowledge, and the actions they send might as well be in the form of evidence that could persuade the other side. Some attempts at persuasion would merely be founded on personal reputation, but mathematical proof and cryptographic evidence would make trust unnecessary in many circumstances.
There’s still the matter of how someone would end up knowing who they can communicate with in the first place, since they have incomplete knowledge of the player-space. The knowledge of a communication channel might as well be just another kind of knowledge, but it’s an interesting one: When a person chooses to share the knowledge of a communication channel with another person, they might not want to just share the channel exactly as they found it; they might want something like the fine-grained encapsulation of RDP dynamic behaviors in order to build rich, subtle structures of interaction.
In short, the idea is that a person observes the world as nothing but a set of known truth, and they impact it in no way other than sending truths of their own along communication channels they know about. The truths they send could be derived in various ways from the truths they observe, and these derived truths could have significant features like private communication opportunities and self-evidence.
In the interest of referring to this idea later, I’m calling it “Reactive Knowledge Networking,” or RKN for short. I hope this conveys the reactive execution semantics, the pervasive use of monotonic partial knowledge, and the emphasis on everyday computer-aided person-to-person interaction (“networking”) rather than specialist human-to-computer interaction (“programming”). The term “knowledge networking” has already been used (link, link) with the connotation of a similar problem domain, yet without my goal of ethical simplicity or the RDP-like computational model.
Drawbacks and challenges
The model as I’ve described it here doesn’t deal with network delay or disruption. Network delay might actually be abusable as a kind of implicit state! RDP specifically accounts for this phenomenon, and as I iron out out the details of RKN, I’m very likely to incorporate RDP’s static delays (to tame that state and make network disruption clear when it happens) and duration coupling (so that connections can be cleaned up when they’re done). There’s a certain elegance to the idea that every communication channel is always active, just not always informative or effective, but that elegance might be a tad too idealistic!
RKN involves a phenomenal UX hurdle: Ideally, it should be utterly effortless for a person to comprehend their knowledge and generate their own custom knowledge along communication channels, no matter how that person is currently equipped to interact with the network. On top of that, it needs to be effortless for people to use their data storage hardware, since it’s no longer going to use itself!
Hopefully if we start designing networks with this kind of idealized interaction in mind, we’ll be able to gradually improve the user experience as we go. I’m interested in whether users could easily build their own tailor-made user interfaces out of pieces they find on the network, the same way they download Web browsers and OSes from the Web today. If interaction bottlenecks remain despite this self-improvement phenomenon, the RKN model should probably adapt to accommodate.
I’m designing this system as though people are the only thing needed at the edges, but if RKN must be glued to another computational model, it would be ethically awkward if we had to depict that model as part of the “people” just so it could connect. The RKN model should expand to support other external interfaces as appropriate.
Reactive Knowledge Networking is an idea that could take a while to solidify, but it’s already the most solid incarnation my belief system has ever taken, and I look forward to trying to flesh out this framework of metaphors and make it practical for application development. Or should I say, communication development!