The Emerging Web of Social Machines

We define a notion of social machine and envisage an algebra that can describe networks of such. To start with, social machines are defined as tuples of input, output, processes, constraints, state, requests and responses; apart from defining the machines themselves, the algebra defines a set of connectors and conditionals that can be used to describe the interactions between any number of machines in a multitude of ways, as a means to represent real machines interacting in the real web, such as Twitter, Twitter running on top of Amazon AWS, mashups built using Twitter and, obviously, other social machines. This work is not a theoretical paper as yet; but, in more than one sense, we think we have found a way to describe web based information systems and are starting to work on what could be a practical way of dealing with the complexity of this emerging web of social machines that is all around us. This version should be read as work in progress and comments, observations, bugs… are most welcome and should be sent to the email of the first, corresponding author.

💡 Research Summary

The paper introduces the notion of a “social machine” as a formal abstraction for any web‑based service, cloud component, or mash‑up that participates in the modern, highly interconnected web. A social machine is defined as a 7‑tuple consisting of input, output, processes, constraints, state, requests, and responses. This definition deliberately separates a service’s internal logic (processes) from its external interface (inputs, outputs, requests, responses) while also capturing operational limits (constraints) and mutable context (state). By modeling each service in this way, the authors aim to provide a uniform language for describing heterogeneous components ranging from a Twitter API endpoint to an Amazon Web Services (AWS) auto‑scaling group.

The central technical contribution is an algebra that specifies how social machines can be combined. The algebra includes a set of connectors that describe data flow between machines, as well as conditional, sequential, and parallel composition operators. For example, “A → B” denotes a simple pipeline where A’s output feeds B’s input, while “A ⊕ B” represents parallel execution whose results are merged. Conditional operators allow the construction of branches based on runtime values, enabling expressive workflow specifications that go beyond static orchestration languages such as BPEL. The algebra is intentionally minimal yet expressive enough to capture common integration patterns (fan‑out, fan‑in, map‑reduce style compositions, etc.) in a mathematically rigorous fashion.

To demonstrate feasibility, the authors model three concrete cases. First, the Twitter API is expressed as a social machine with inputs (search terms, user IDs), outputs (tweet streams), processes (filtering, sentiment analysis), constraints (rate limits, policy rules), state (recent queries, follower lists), requests (HTTP GET/POST), and responses (JSON payloads). Second, AWS is modeled similarly, focusing on its request‑response interface for provisioning resources, its constraints (quota, cost), and its mutable state (running instances, load metrics). Third, a mash‑up that connects Twitter to AWS is built using the algebra: tweets are streamed, analyzed in real time, and when certain keywords exceed a threshold, a conditional triggers an AWS scaling operation. This composite is succinctly expressed as a composition of the two machines with a conditional branch, illustrating how the algebra can capture dynamic, data‑driven orchestration without writing imperative code.

The paper acknowledges that the work is still at a proof‑of‑concept stage. It does not yet provide an implementation framework, code generators, or verification tools. The authors outline future directions: (1) extending the algebra to handle mutable state updates and dynamic constraints, (2) integrating security concerns such as authentication, authorization, and SLA enforcement, (3) building tooling for automatic translation of algebraic specifications into executable orchestration scripts (e.g., Docker Compose, Kubernetes manifests), and (4) developing formal verification techniques to prove properties like dead‑lock freedom or compliance with rate limits. They also note that while the algebra captures static composition elegantly, real‑world services often evolve (API version changes, policy updates) and require mechanisms for runtime adaptation.

In conclusion, the paper proposes a novel, mathematically grounded framework for describing the “emerging web of social machines.” By abstracting diverse web services into a common tuple and providing a compositional algebra, it offers a promising route to tame the growing complexity of micro‑service ecosystems, serverless functions, and API‑driven mash‑ups. If the proposed algebra can be integrated with practical tooling and extended to address dynamic, security‑related aspects, it could become a valuable addition to the toolbox of architects and developers seeking systematic, verifiable ways to design and manage large‑scale, interconnected web applications.