Abstract We present Jay, a software framework for offloading applications in hybrid edge clouds. Jay provides an API, services, and tools that enable mobile application developers to implement, instrument, and evaluate offloading applications using configurable cloud topologies, offloading strategies, and job types. We start by presenting Jay's job model and the concrete architecture of the framework. We then present the programming API with several examples of customization. Then, we turn to the description of the internal implementation of Jay instances and their components. Finally, we describe the Jay Workbench, a tool that allows the setup, execution, and reproduction of experiments with networks of hosts with different resource capabilities organized with specific topologies. The complete source code for the framework and workbench is provided in a GitHub repository.

We present Dolphin, an extensible programming language for autonomous vehicle networks. A Dolphin program expresses an orchestrated execution of tasks defined compositionally for multiple vehicles. Building upon the base case of elementary one-vehicle tasks, the built-in operators include support for composing tasks in several forms, for instance according to concurrent, sequential, or event-based task flow. The language is implemented as a Groovy DSL, facilitating extension and integration with external software packages, in particular robotic toolkits. The paper describes the Dolphin language, its integration with an open-source toolchain for autonomous vehicles, and results from field tests using unmanned underwater vehicles (UUVs) and unmanned aerial vehicles (UAVs).

F lux is a platform for dynamically reconfigurable crowd-sensing using mobile devices like smartphones and tablets, programmed under a notion of region-based sensing. Each region is defined by a set of physical constraints that determine the sensing scope, e.g., based on device position or other environmental variables, plus a set of periodic tasks that perform the actual sensing. The resulting behavior is inherently dynamic: as a device’s state changes, e.g., moves in space, it enters and/or leaves different regions, thereby changing the set of active tasks; moreover, regions can be added, deleted, and reprogrammed on-the-fly. F lux makes use of a domain-specific language for sensing tasks that is compiled into abstract bytecode, later executed by a low-footprint virtual machine within a device, guaranteeing runtime safety by construction. For region/task dissemination, F lux employs a broker that holds a changeable region configuration plus gateways that mirror the configuration throughout different network access points to which devices connect. Sensing data is streamed by devices to gateways and then back to the broker. Live or archived data streams are in turn fed by the broker to data-processing clients, which interface with the broker using a publish/subscribe API. We conducted two case-study experiments illustrating F lux : a single-region deployment to monitor WiFi signal quality, and a multi-region deployment to monitor noise, temperature, and places-of-interest based on device movement.

We present ParTypes, a type-based methodology for the verification of Message Passing Interface (MPI) programs written in the C programming language. The aim is to statically verify programs against protocol specifications, enforcing properties such as fidelity and absence of deadlocks. We develop a protocol language based on a dependent type system for message-passing parallel programs, which includes various communication operators, such as point-to-point messages, broadcast, reduce, array scatter and gather. For the verification of a program against a given protocol, the protocol is first translated into a representation read by VCC, a software verifier for C. We successfully verified several MPI programs in a running time that is independent of the number of processes or other input parameters. This contrasts with alternative techniques, notably model checking and runtime verification, that suffer from the state-explosion problem or that otherwise depend on parameters to the program itself. We experimentally evaluated our approach against state-of-the-art tools for MPI to conclude that our approach offers a scalable solution.

The Hierarchical Timing Language (HTL) is a real-time coordination language for distributed control systems. HTL programs must be checked for well-formedness, race freedom, transmission safety (schedulability of inter-host communication), and time safety (schedulability of host computation). We present a modular abstract syntax and semantics for HTL, modular checks of well-formedness, race freedom, and transmission safety, and modular code distribution. Our contributions here complement previous results on HTL time safety and modular code generation. Modularity in HTL can be utilized in easy program composition as well as fast program analysis and code generation, but also in so-called runtime patching, where program components may be modified at runtime.