Scaffold

How can we program at scale to ensure highly- decentralised, lightweight protocols and algorithms utilise the mix of heterogeneous computational devices dispersed throughout future cities?

Partners

Imperial College London

Network-wide programming allows us to overcome the cognitive overload of programming a large heterogenous network of devices.

A significant reduction in the codebase that needs to be maintained.

A runtime that automatically registers devices with minimal overhead.

A proof framework shows that no semantics are lost through network-wide programming as compared to programming devices individually.

The Smart City vision is to have widespread sensing of city conditions to guide infrastructure, policies and services. However, we must be careful in how we instrument the city and

not lose track of long-term consequences. When sensing truly becomes ubiquitous, bringing with it an explosion of devices communicating data, then existing network infrastructures will become saturated. This motivates IoT and sensor nodes running multiple applications that might belong to different stakeholders. This leads to a continuum where data is processed from source devices via edge devices to the cloud. The question is where do we carry out processing: with what nodes and how? Specifically, maximizing the use of these systems is important but also brings many challenges in terms of scheduling processes and programming systems without knowing where they run.

We view the city as a programmable device. The traditional approach to programming over many devices is to place a runtime on all nodes to abstract away the underlying hardware. We take a different approach. Given that code deployment can be initiated remotely and at any time, it makes sense to instead adapt compiler based approaches where optimisation is done when the application is compiled/ initially deployed. We believe that in order to cope with the large heterogeneity present in our target networks we should aim to have controlled variation, rather than arbitrary homogeneity. This ensures that hard to foresee complex interactions involving the placement of computation and communications can be ironed out in advance.

To this end we have developed a framework for developing smart city applications, which we name Scaffold. The main component of this framework consists of a compiler, which takes a program annotated with source data, commands and requirements in our Scale language and automatically determines the minimal set of actual programs that will need to be running in the nodes that compose the network, cloud to edge. Depending on the requirements this compiler can also inject the programs with runtimes, allowing for dynamic behaviour, whilst retaining as much intelligibility as possible.

We have also developed Scanner, a registry and automatic deployment system for sensors, actuators and processor nodes in smart city scenarios. This system allows us to take the output of the Scale compiler and query the current state of the network in order to determine appropriate target nodes in which to install the various images produced by the Scale compiler. In order to have optimal communications and satisfy application requirements, we need to be able to distribute the application layout in the network in the best way. That could range from in-network processing to cloud computing. Optimising the layout of the application in the heterogeneous network thus implies that the nodes inside the network might be doing processing and relaying for applications that are not the ones produced by their owners. This implies a notion of multi-tenancy, quotas and process isolation.