The strong divide between applications and the network control plane is desirable, but keeps the network in the dark regarding the ultimate purpose of applications and, as a result, is unable to optimize for these. An alternative approach is for applications to declare to the network their abstract desires; e.g. “I require group multicast”, or “I will run within a local domain and am latency sensitive”. Such an enriched semantic has the potential to enable the network to better fulfill application intent, while also helping optimize network resource usage across applications. We refer to this approach as intent driven networking (IDN). We sketch an incrementally-deployable design to serve as a stepping stone towards a practical realization of IDN within today's Internet.

With recent advances in networking and workstation technology, a variety of distributed multimedia applications are now becoming feasible, e.g. multimedia desktop conferencing and distance learning. However, the deployment of such applications has so far been rather limited. In the authors' opinion this limited deployment is largely explained by the immature state of distributed multimedia system support technologies rather than any Jack of creativity on the part of application developers. The present paper therefore attempts to increase awareness of the relevant support technology issues by presenting a discussion of the state of the art in the key technologies of multimedia communications and distributed systems. It is argued that, while significant advances have been made in specific areas such as high performance transport protocols and real-time process scheduling in operating systems, considerable research is still required to produce a complete, integrated solution to the support of distributed multimedia applications.

The world's computing infrastructure is increasingly differentiating into self-contained distributed systems with various purposes and capabilities (e.g. IoT installations, clouds, VANETs, WSNs, CDNs, . . .). Furthermore, such systems are increasingly being composed to generate systems of systems that offer value-added functionality. Today, however, system of systems composition is typically ad-hoc and fragile. It requires developers to possess an intimate knowledge of system internals and low-level interactions between their components. In this paper, we outline a vision and set up a research agenda towards the generalised programmatic construction of distributed systems as compositions of other distributed systems. Our vision, in which we refer uniformly to systems and to compositions of systems as holons, employs code generation techniques and uses common abstractions, operations and mechanisms at all system levels to support uniform system of systems composition. We believe our holon approach could facilitate a step change in the convenience and correctness with which systems of systems can be built, and open unprecedented opportunities for the emergence of new and previously-unenvisaged distributed system deployments, analogous perhaps to the impact the mashup culture has had on the way we now build web applications.

The world's computing infrastructure is increasingly differentiating into self-contained sub-systems (e.g. Internet of Things installations, clouds, VANETs, ...), which are post-hoc composed to generate value-added functionality (“systems of systems”). Today, however, such system-of-systems composition is typically carried out in an ad-hoc and infrastructure-dependent manner, with obvious associated disadvantages. In this paper, we propose a generalised system-of-systems-oriented programming approach that enables programmers to manage the composition of systems without a need for intimate knowledge of their internals, and also facilitates dynamic and spontaneous system composition, as systems discover each other opportunistically in their environment.

Advanced and complex embedded systems as multicore and multiprocessor systems are becoming common and this has stimulated the development of critical applications for them. UAVs (Unmanned Aerial Vehicles) constitute a typical application of a complex critical embedded system. One concept that can result in radically different solutions in UAVs is the use of Service-Oriented Architecture (SOA). The increasing use of SOA in critical applications demands dependable and cost-effective techniques to ensure high security. In this paper we develop a different kind of services for avionics with different parameters (security, reliability and performance) to provide the use of SOA in a less critical part in the whole systems. The use of these services and the KBF (Knowledge Based Framework for Dynamically Changing Applications) presented in this paper can give more intelligence to the UAVs and provide a new form of segregating the UAV mission from the vehicle itself. The services were developed and a performance evaluation was conducted showing the benefits in choosing one service or another.

Middleware has emerged as a key technology in the construction of distributed systems. As a consequence, middleware is increasingly required to be highly modular and configurable, to support separation of concerns between services, and, crucially, to support dynamic reconfiguration: i.e. to be capable of being changed while running. Aspect-oriented middleware is a promising technology for the realisation of distributed reconfiguration in distributed systems. In this paper we propose an aspect-oriented middleware platform called AO-OpenCom that builds AO-based reconfiguration on top of a dynamic component approach to middleware system composition. The goal is to support extremely flexible dynamic reconfiguration that can be applied at all levels of the system and uniformly across the distributed environment. We evaluate our platform by the capability in meeting flexible reconfiguration and the impact of these overheads.

Aspect-oriented (AO) middleware is a promising technology for the realisation of dynamic reconfiguration in distributed systems. Similar to other dynamic reconfiguration approaches, AO-middleware based reconfiguration requires that the consistency of the system is maintained across reconfigurations. AO middleware based reconfiguration is an ongoing research topic and several consistency approaches have been proposed. However, most of these approaches tend to be targeted at specific narrow contexts, whereas for heterogeneous distributed systems it is crucial to cover a wide range of operating conditions. In this paper we address this problem by exploring a flexible, framework-based consistency management approach that cover a wide range of operating conditions ensuring distributed dynamic reconfiguration in a consistent manner for AO-middleware architectures.

Wireless sensor and actuator networks (WSANs) will increasingly require support for managed software evolution: that is, systematic, ongoing, efficient and nondisruptive means of updating the software running on the nodes of a WSAN. While aspects of this requirement have been examined in the literature, the big picture remains largely untouched, resulting in the generally static WSAN deployments we see today. In this article, we propose a comprehensive approach to managed software evolution. Our approach has the following key features: (i) it supports divergent evolution of the WSAN's software, such that different nodes can evolve along different lines (e.g., to meet the needs of different stakeholders, or to address localized adaptations) and (ii) it supports both instructed and autonomous evolution such that nodes can be instructed to change their software configuration or can evolve their own configuration (e.g., to manage rapidly-changing environmental conditions where remote micromanagement would be infeasible due to the high latency of the WSAN environment). We present the four intra-WSAN protocols that comprise our solution, along with an accompanying server-side infrastructure, and evaluate our approach at scale.

This paper presents a new form of consensus that allows nodes to agree locally on the extent of crashed regions in networks of arbitrary size. One key property of our algorithm is that it shows local complexity, i.e. its cost is independent of the size of the complete system, and only depends on the shape and extent of the crashed region to be agreed upon. In this paper, we motivate the need for such an algorithm, formally define this new consensus problem, propose a fault-tolerant solution, and prove its correctness.

Based on the trends of divergent sensor node software evolution and on-node multi-application coexistence observed from a real smart city WSAN deployment, we propose requirements for optimum exploitation of the infrastructure. In particular, we advocate the need to switch between concurrency models depending on usage context.

Virtual testbeds model them by seamlessly integrating physical, simulated, and emulated sensor nodes and radios in real time.

Modular software, in which strongly-separated units of functionality can be independently added to and removed from a node's running software, offers a promising approach to effective dynamic software updating in Wireless Sensor Networks (WSNs). Modular software updating approaches offer high efficiency, in terms of both network costs and update installation at nodes, as well as low disruption, allowing existing software to continue to operate during updates. Existing approaches however critically lack safety, relying on weakly-typed event-based programming abstractions for inter-module interaction. This precludes compile-time or composition-time verification of interoperability between dynamically loaded modules and therefore presents major risks for future large-scale production-class deployments. In this paper we present Lorien: a component-based modular operating environment that employs interface-based inter-component interaction to support completely type-safe software composition, while still supporting high update efficiency and low disruption. Our approach also has very wide scope, allowing almost 90% of software to be remotely updated on common sensor platforms such as the TelosB. We compare Lorien against existing modular designs, finding that the safety properties of Lorien are offered with near equal efficiency.

We present a design that accommodates ‘virtual mobility’ in a wireless sensor network testbed. Virtually-mobile nodes can be physical, simulated or emulated, and virtual mobility for all three types is treated uniformly by embedding the nodes in a virtual space. In operation, the traffic of virtually-mobile nodes is intercepted and redirected to a mobility model from where it is selectively forwarded to other nodes that are virtually in range. We present a distributed implementation architecture that potentially allows the simulation/emulation of large-scale wireless sensor networks with large numbers of virtually-mobile nodes.

flexible experimentation in wireless sensor networks significant drawbacks when used in isolation (see the sidebar “Physical Testbeds vs. Simulation vs. Emulation”). Therefore, they seek to combine all three to enable a more complete evaluation of the system being developed. Unfortunately, each approach requires different coding styles and tools, forcing researchers to expend significant effort reimplementing their systems for different tools/ platforms/approaches. As a remedy, techniques have been developed to reduce the transitioning effort among the three approaches, but further work is needed to address the emerging requirement for more flexible experimental facilities. Our work abstracts the concept of testbeds to yield virtual testbeds (VTBs) programmed similarly regardless of whether their underlying realization is physical, simulated, or emulated. VTBs are private, custom-designed, per-experiment, virtualized testbed instances that enable developers to seamlessly combine and/or interchange physical elements, including sensor nodes and radios, with simulations and emulations of these elements. We are developing a reference implementation of the VTB abstraction on top of a large-scale federated physical testbed infrastructure (see Figure 1), augmenting the inherent flexibility of the VTB abstraction in terms of scalwIReLess sensoR neTwo RKs (WSNs) play a key role in the emerging “real-world Internet,” with several large-scale WSNs being deployed; see, for example, Bernat2 and Dudek et al.9 However, WSN development is inherently complex, involving hardware design, embedded and distributed programming, heterogeneity, scale, and unpredictable environmental changes. Addressing this complexity, testbed-based experimentation (recommended by Weiser) is increasingly the norm for developing and optimizing WSN systems in a controllable environment prior to deployment. The WSN research community has historically relied on three main approaches to testbed-based experimentation: physical, simulation, and emulation. However, researchers appreciate that each involves key insights

In this paper we provide a detailed discussion and evaluation of the theoretical and practical differences between static and dynamic component models as the foundations of programming wireless sensor nodes. As the static benchmark we examine the nesC component model underpinning TinyOS; and as the dynamic benchmark we examine the OpenCom component model underpinning the Lorien operating system. Both models are well established in their respective domains and have at least 2nd generation implementations available. We identify 4 key mechanisms required by the dynamic approach beyond those needed by the static approach, and using the TelosB implementations of both models we demonstrate the performance differences involved in the support of each of these mechanisms. We conclude that while the static approach has inevitably better performance, the overhead of the dynamic approach is suffciently low that it is a promising foundation in support of future WSN research in dynamic and adaptive systems.

Grid computing is becoming increasingly pervasive; sensor networks and mobile devices are now connected with traditional Grid infrastructure to form geographically diverse complex systems. Applications of this type can be classified as the Pervasive Grid. In this chapter we examine how traditional Grid technologies and middleware are inherently unsuited to address the challenges of extreme heterogeneity and fluctuating environmental conditions in these systems. We present Gridkit, a configurable and reconfigurable reflective middleware that leverages overlay networks and dynamic software in response to the requirements of the Pervasive Grid. We also illustrate how Gridkit has been used to deploy a flood monitoring application at a river in the north west of England; this demonstrates both the flexibility Gridkit provides, and how dynamic adaptation optimises performance and resource consumption.

In aspect-oriented middleware systems, the aspect modules are typically composed as chains of aspects within the connectors (or bindings) that join the base software components. However, this approach can lose or hide information about the dependencies between multiple aspects in the chain; this is particularly important when dynamically reconfiguring such a system at runtime. Without knowledge of these dependencies the system could reconfigure a new aspect with a dependency to a prior aspect in the chain resulting in a cyclic dependency and subsequent deadlock. Furthermore, the problem is harder to detect with the presence of remote aspects within the connectors as their dependencies are hidden across address spaces. To resolve cyclic dependencies that may occur when reconfiguring both local and remote aspects we propose the use of a reconfiguration cyclic dependency resolution (ReCycle) model. This approach can be employed generally in dynamic AOP middleware platforms, and in this paper we evaluate it within the AO-OpenCom middleware.