In this demonstration we show drag-and-drop distribution of centralized, modular Java applications. Our system is based on OSGi, an industry standard for building Java applications out of modular units loosely connected through services. Since OSGi is a centralized system, we have elaborated a solution to seamlessly distribute OSGi applications along the boundaries of services and thereby turning arbitrary OSGi applications into distributed applications. In this demonstration, we present an Eclipse based tool that takes the source code of an OSGi application as input, produces a graph of its modules and module dependencies, and allows the user to deploy the application across a distributed system by dragging-and-dropping its constituent modules on different machines. By defining constraints on the distribution, the tool can also support advanced features like load-balancing or redundancy of modules.@en

As mobile and embedded devices become widespread, the management and configuration of the software in the devices is increasingly turning into a critical issue. OSGi is a business standard for the life cycle management of Java software components. It is based on a service oriented architecture where functional units are decoupled and components can be managed independently of each other. However, the focus continuously shifts from the originally intended area of small and embedded devices towards large-scaled enterprise systems. As a result, implementations of the OSGi framework are increasingly becoming more heavyweight and less suitable for smaller computing devices. In this paper, we describe the experience gathered during the design of Concierge, an implementation of the OSGi specification tailored to resource-constrained devices. Comprehensive benchmarks show that Concierge performs better than existing implementations and consumes less resources.@en

Mobile phones are rapidly becoming the universal access point for computing, communication, and digital infrastructures. In this paper we explore the software architectures necessary to make the mobile phone a truly universal access point to any electronic infrastructure. We propose AlfredO, a lightweight middleware architecture that allows developers to construct applications in a modular way, organizing the applications into detachable tiers that can be distributed at will to dynamically configure multi-tier architectures between mobile phones and service providers. Through AlfredO, a phone can lease on-the-fly the client side of an application and immediately become a fully tailored client. Our experimental results indicate that AlfredO has very little overhead, it is scalable, and yields very low latency. To demonstrate the feasibility and potential of the platform, in the paper we also describe AlfredOShop, a prototype application for spontaneously controlling information screens from a mobile phone.@en

Writing applications for sensor networks often involves low-level programming. In this demo we show a generic sensor network platform (SwissQM/SwissGate) that provides a high level interface for programming sensor networks and also provides a multi-tier architecture for efficiently handling and optimising the operation of the network. The demo is based on a small scale (deployment in a building) where the network is used concurrently by several applications to measure heating, ventilation, and air conditioning control (HVAC) parameters. The network also implements several event detection functions for fire, burglar, and user triggered alarms. In the demo we show how the sensor network can be programmed using queries in several languages (SQL, Java, XQuery), including user-defined functions (in a C-like language) and the results obtained as a stream of data tuples. We also show the ability to efficiently use the network concurrently.@en

In this paper we take advantage of the concepts developed for centralized module management, such as dynamic loading and unloading of modules, and show how they can be used to support the development and deployment of distributed applications. We do so through R-OSGi, a distributed middleware platform that extends the centralized, industry-standard OSGi specification to support distributed module management. To the developer, R-OSGi looks like a conventional module management tool. However, at deployment time, R-OSGi can be used to turn the application into a distributed application by simply indicating where the different modules should be deployed. At run time, R-OSGi represents distributed failures as module insertion and withdrawal operations so that the logic to deal with failures is the same as that employed to deal with dependencies among software modules. In doing so, R-OSGi greatly simplifies the development of distributed applications with no performance cost. In the paper we describe R-OSGi and several use cases. We also show with extensive experiments that R-OSGi has a performance comparable or better than that of RMI or UPnP, both commonly used distribution mechanisms with far less functionality than R-OSGi.@en

Stream processing systems have evolved into established solutions as standalone engines but they still lack flexibility in terms of large-scale deployment, integration, extensibility, and interoperability. In the last years, a substantial ecosystem of new applications has emerged that can potentially benefit from stream processing but introduces different requirements on how stream processing solutions can be integrated, deployed, extended, and federated. To address these needs, we present an exoengine architecture and the associated ExoP platform. Together, they provide the means for encapsulating components of stream processing systems as well as automating the data exchange between components and their distributed deployment. The proposed solution can be used, e.g., to connect heterogeneous streaming engines, replace operators at runtime, and migrate operators across machines with a negligible overhead.@en

Updating software at runtime is a challenge that covers various aspects of software design and runtime systems. The OSGi Alliance has proposed and standardized a runtime system for composing Java applications out of modules, the OSGi Framework. The possibility to update modules at runtime and thereby dynamically change the application has been an intrinsic design decision of the framework architecture. With recent approaches to extend the OSGi model from single Java virtual machines to distributed systems, however, updates no longer only affect a single machine in the system. The specifications of OSGi and the upcoming proposals for distributed OSGi services do not answer the question how to consistently apply updates in such environments. In this paper, we explore a solution based on our R-OSGi system. We show how to extend the existing (local) OSGi update mechanism to consistently apply updates to multiple nodes of a distributed OSGi application.@en

SwissQM is a novel sensor network platform for acquiring data from the real world. Instead of statically hand-crafted programs, SwissQM is a virtual machine capable of executing bytecode programs on the sensor nodes. By using a central and intelligent gateway, it is possible to either push aggregation and other operations into the network, or to execute them on the gateway. Since the gateway is built in an entirely modular style, it can be dynamically extended with new functionality such as user interfaces, user defined functions, or additional query optimizations. The goal of this demonstration is to show the flexibility and the unique features of SwissQM.@en

One of the most important challenges that need to be solved before the "Internet of Things" becomes a reality is the lack of a scalable model to develop and deploy applications atop such a heterogeneous collection of ubiquitous devices. In practice, families of hardware devices or of software platforms have intrinsic characteristics that make it very cumbersome to write applications where arbitrary devices and platforms interact. In this paper we explore constructing the software fabric for the "Internet of Things" as an extension of the ideas already in use for modular software development. In particular, we suggest to generalize the OSGi model to turn the "Internet of Things" into a collection of loosely coupled software modules interacting through service interfaces. Since OSGi is Java-based, in the paper we describe how to use OSGi concepts in other contexts and how to turn non-Java capable devices and platforms into OSGi-like services. In doing this, the resulting software fabric looks and feels like well known development environments and hides the problems related to distribution and heterogeneity behind the better understood concept of modular software design.@en

Cloud computing faces many of the challenges and difficulties of distributed and parallel software. While the service interface hides the actual application from the remote user, the application developer still needs to come to terms with distributed software that needs to run on dynamic clusters and operate under a wide range of configurations. In this paper, we outline our vision of a model and runtime platform for the development, deployment, and management of software applications on the cloud. Our basic idea is to turn the notion of software module into a first class entity used for management and distribution that can be autonomously managed by the underlying software fabric of the cloud. In the paper we present our model, outline an initial implementation, and describe a first application developed using the ideas presented in the paper.@en