We’d like to change the way in which social machines are built. The central premise is: there is a model of interaction which sits behind any social machine, governing who can do what when, which kinds of messages can be sent and to whom, shaping the ways in which the complex socio-technical system unfolds through time. However, these interaction models are often not explicit, transparent, editable, discoverable, composable and so on, as they are scattered through many interacting pieces of code. In response, we are looking at a way to create social computation systems by starting with an interaction model, allowing all of the other components of a modern, large scale interactive system to be organised around a representation of the communication and coordination which takes place.
In order to explore this space, a modified version of the Lightweight Coordination Calculus (LCC) is used, termed the Lightweight Social Calculus (LSC). It is an executable, declarative process calculus for interactions between heterogeneous agents. Use of LSC is based on the enaction of protocols, which give a minimally intrusive framework for defining patterns of communication without overly constraining the internal knowledge and decision making architecture of the actors involved.
There are several motivations for doing this:
- Since protocols can be mechanically enacted, they provide the potential for mixed initiative human computer interaction and human computation applications. Creating a protocol which represents human interaction allows computational agents to join in on an equal footing with the humans.
- Making protocols first class objects allows for their exchange and manipulation. It means that communities can discover interactions which suit their needs and adopt them, after making any modifications necessary.
- Protocols can be transparent to users, indicating what the bounds and rules of the interactions are, leading to a greater facility for understanding the implications of engaging. This does, of course, on being able to represent the protocols in a manner which makes sense to users.
- There is a clear separation of concerns between the structure of the interac- tion and the mediums and communities where it is enacted. The interaction can then be framed in a manner which is most appropriate to the community in question, and integrated into their existing practice by connecting the in- teraction model with the technical platforms already in use—essentially, the interaction becomes key, rather than the substrate on which it is performed.
- A protocol is amenable to formal techniques. For example, properties can be verified, such as the flow of data through the interaction, termination criteria, and other qualities which relate to privacy and security.
In order for this to work, humans need some way to engage with protocols as they are enacted. One mechanism for doing this is to create an interface with which people can engage, whether through webpages or mobile devices, or mediated through APIs of some sort. This is the means of engagement with which we’re familiar from earlier LCC work. Another possibility is to find a way to run the protocols alongside existing interaction, annotating their behaviour with formal structures. We call this approach ‘Soft Institutions’, where the formal edges of electronic institutions are softened to provide natural, human ways for people to engage with them.
LSC is a declarative, executable specification designed to give enough structure to manage fully distributed interactions by coordinating message passing and the roles which actors play, while leaving space for the actors to make their own decisions. It is derived from LCC with extensions designed to make it more amenable to mixed human-machine interactions; in practice, this means having language elements which cover user input, external computation or database lookup and storing knowledge and state.