In this article, we present and analyze MUSANet, a hierarchical, distributed, context-aware architecture for collecting, processing, and distributing data in smart cities. We discuss some use case examples related to monitoring and predicting bus arrivals in public transportation and weather conditions. We also present performance results in different scenarios that point to the feasibility of our goal: a scalable architecture with a fast response time to traffic events. MUSANet is based on a three-tier architecture distributed over the cloud, fog, and edge, and supporting complex event processing (CEP) in all of them. Although the system is under development using the InterSCity platform in the cloud, the ContextNet middleware at the fog, and the Mobile-Hub platform at the edge, the MUSANet architecture can be deployed using other platforms, maintaining the concept of tiering responsibilities to minimize network bandwidth and delay, group communication, and broad mobile support.

C éU is a synchronous language targeting soft real-time systems. It is inspired by Esterel and has a simple semantics with fine-grain control over program execution. C éU uses an event-triggered notion of time that enables compile-time checks to detect conflicting concurrent statements, resulting in deterministic and concurrency-safe programs. We present the particularities of our design in comparison to Esterel, such as stack-based internal events, concurrency checks, safe integration with C, and first-class timers. We also present two implementation back ends: one aiming for resource efficiency and interoperability with C, and another as a virtual machine that allows remote reprogramming.

The integration of multimedia frameworks and APIs for accessing cognitive computing systems into a unified programming model may not be straightforward. Current solutions use programming models that lead to problems like callback hell or synchronization of threads. In this paper, we explore the use of the reactive programming paradigm to create multimedia applications that explore cognitive computing systems features. By using CÉU as instance of reactive language, we discuss how this approach promotes a straightforward integration between these domains, while avoiding the aforementioned issues. We discuss the implementation of two case studies to illustrate the advantages of this approach.

Overload control requires different scheduling policies in different application scenarios. In this work, we propose an API that allows the programmer to choose and program scheduling policies in the specific setting of a staged event driven architecture. Through the study of various scheduling policies, we have extracted common requirements and built an interface that allows developers to build and combine scheduling controllers. The implementation is specific to the Leda event driven architecture, but the same model could be applied in other systems with similar needs. Using this interface, we have built controllers for a set of scheduling policies, and we report the results of experiments with these policies in two Leda applications with different load profiles.

Terra is a system for programming wireless sensor network (WSN) applications. It combines the use of configurable virtual machines with a reactive scripting language that can be statically analyzed to avoid unbounded execution and memory conflicts. This approach allows the flexibility of remotely uploading code on motes to be combined with a set of guarantees for the programmer. The choice of the specific set of components in a virtual machine configuration defines the abstraction level seen by the application script. We describe a specific component library built for Terra, which we designed taking into account the functionality commonly needed in WSN applications—typically for sense and control. We also discuss the programming environment resulting from the combination of a statically analyzable scripting language with this library of components. Finally, we evaluate Terra by measuring its overhead in a basic application and discussing its use and cost in a typical monitoring WSN scenario.

With current advances in the deployment of testbeds for Future Internet (FI), a new challenge arises: identity management in a globally distributed environment. In this context, it is necessary to understand local and federated models of identity management to integrate testbeds. This paper presents the design and implementation of a module for credential translation that enables a user of an academic authentication and authorization (A&A) federation, such as CAFe (the Brazilian Federated Academic Community), to access the FI testbed federation. The proposed model supports the integration of testbed federations and academic federations. The proposal generates X.509 certificates and other standard credentials used in the testbed federation, following the SFA standard, based on user attributes obtained from the A&A federation (CAFe). The developed module also allows an attribute-based access control, denying or allowing a user access according to his/her attributes obtained from CAFe. Other contributions are based on facilities for the user to delegate his SFA credential to an experimenter control interface. The study was conducted using a real experimentation laboratory (GIDLab), in which mirrors of the CAFe federation and of the MySlice platform were set up to allow the comparison of security features of our scheme to other proposals.

The Staged Event Driven Architecture (SEDA) can be seen as a milestone as regards integration of threads and events in a single model. By decomposing applications into sets of multi-threaded stages connected by event queues, SEDA allows for the use of each concurrency model where most appropriate. Inside each SEDA stage, the number and scheduling policy of threads can be adjusted to enhance performance. SEDA lends itself to parallelization on multicores and is well-suited for many high-volume data stream processing systems and highly concurrent event processing systems. In this paper, we discuss the design of Leda, a platform that extends the staged model proposed by SEDA, decoupling application design from specific execution environments. In Leda, stages are defined purely by their role in application logic, with no concern for locality of execution, and are bound together through asynchronous communication channels, called connectors, to form a directed graph representing the flow of events inside the application. Decisions about the configuration of the application at execution time are delayed to later phases of the implementation process. Stages in the application graph can then be grouped to form clusters, and each cluster is mapped to an exclusive OS process, running on an arbitrary host. The paper briefly reviews a classification of hybrid concurrent models in order to establish SEDA's and Leda's role in this space. It then describes the design of Leda, which emphasizes decoupling at several levels, and discusses how its implementation in Lua helped to reinforce these design goals.

Despite the continuous research to facilitate WSNs development, most safety analysis and mitigation efforts in concurrency are still left to developers, who must manage synchronization and shared memory explicitly. In this paper, we present a system language that ensures safe concurrency by handling threats at compile time, rather than at runtime. Based on the synchronous programming model, our design allows for a simple reasoning about concurrency that enables compile-time analysis resulting in deterministic and memory-safe programs. As a trade-off, our design imposes limitations on the language expressiveness, such as doing computationally-intensive operations and meeting hard real-time responsiveness. To show that the achieved expressiveness and responsiveness is sufficient for a wide range of WSN applications, we implement widespread network protocols and the CC2420 radio driver. The implementations show a reduction in source code size, with a penalty of memory increase below 10% in comparison to nesC. Overall, we ensure safety properties for programs relying on high-level control abstractions that also lead to concise and readable code.

Abstract The emergence of new environments, such as grids and mobile devices, poses new requirements for programming systems and models. Migration techniques, which have been extensively studied but not widely used, gain a chance to rise in light of these requirements. This survey reviews a particular case of migration that fits well into those environments—that is, heterogeneous strong migration of running computations at application level. We approach it from an implementation point of view, commenting on related issues and current solutions. We discuss the strong influence that language support for migration has on implementation issues, and the advantages that a higher level of support would represent for the portability and performance of the application, as well as in terms of control and flexibility for the programmer. Copyright © 2007 John Wiley & Sons, Ltd.

The Grid's intrinsic characteristics of high instability and unpredictability, makes adaptation a must-have requirement. The capability of moving a running computation to another available host has the desirable property of allowing the topology of distributed applications to adapt dynamically, reacting to changes in the environment. An outstanding example is that of opportunistic computing, where a mechanism must exist in order to evict remote computations in favor of the local owner. This work studies the problem of heterogeneous strong migration, identifying its structure and the taxonomy of the methods currently used for its implementation.

This paper proposes a concurrency model which integrates the asynchronous and event-driven nature of wireless sensor networks with higher-level abstractions that provide a more familiar programming style for the developer. As a basis for this proposal, we designed and implemented a cooperative multitasking scheduler, based on coroutines, for the TinyOS operating system. We then used this scheduler to implement RPC-like interfaces that capture different communication patterns common in wireless sensor networks. This allows the programmer to work, when appropriate, with a synchronous style, while maintaining an asynchronous model at the message exchange level.

Abstract The heterogeneous and dynamic nature of Grid environments place new demands on models and paradigms for parallel programming. In this work we discuss how ALua, a programming system based on a dual programming language model, can help the programmer to develop applications for this environment, monitoring the state of resources and controlling the application so that it adapts to changes in this state. Copyright © 2004 John Wiley & Sons, Ltd.

The use of scalable management tools is becoming more and more important for integrated management of different network platforms. This work explores the resources of the interpreted language Lua to create a flexible environment for Web-based distributed network management. This environment includes services for monitoring and asynchronous event handling, both available through CORBA interfaces. The dynamic characteristics of our environment allow the administrator to extend or modify functionality without stopping the system, and also to redefine dynamically the group of servers supporting the network management application.