Supporting Maintainable Exception Handling with Explicit Exception Channels

EThOS - Electronic Theses Online ServiceGBUnited Kingdo

Thinking Smart Cities as Systems-of-Systems: A Perspective Study

International audienceSmart cities typically encompass several of distributed systems engaged in complex relationships including the integration and interaction with other systems towards providing new functionalities. These relationships lead to the so-called systems-of-systems (SoS), a widespread set of independent, heterogeneous complex systems that have their own purpose and collaborate with each other to fulfill common global missions. The SoS concept has indeed emerged as an active domain of research in recent years and it is of crucial importance for the societal challenges facing the world. In this perspective, we herein present how a smart city itself can be holistically viewed as a complex SoS and shed light on some challenges related to the development of this type of systems in the context of smart cities

A Component-Based Adaptation Approach for Multi-Cloud Applications

International audienceThis paper presents a dynamic adaptation process for multi-cloud applications that is composed of two phases. The first one is a modeling phase, which borrows the ability for representing commonalities and variabilities from the software product lines (SPL) paradigm. In this phase, a customized model feature specifies the configuration of cloud services to be used by an application (commonalities) and the different possible providers for each service (variabilities). The second phase is an implementation phase, which relies on the Mape-K autonomic loop to define the steps of an adaptation strategy and a centralized knowledge management provides the proper inputs for each step. Finally, in order to make easier the task of developing the adaptation process itself, the current implementation of the adaptation strategy relies on the FraSCAti component framework, which allows performing wiring and unwiring operations between components

Improving modularity of reflective middleware with aspect-oriented programming

Reflective middleware has been proposed as an effective way to enhance adaptability of component-oriented middleware architectures. To be effectively adaptable, the implementation of reflective middleware needs to be modular. However, some recently emerged applications such as mobile, pervasive, and embedded applications have imposed more stringent modularity requirements to the middleware design. They require support for the conception of a minimal middleware while promoting finegrained modularity of reflective middleware features. The key problem is that fundamental mechanisms for decomposing reflective middleware implementations, such as object-oriented ones, suffer from not providing the proper means to achieve the required level of localizing reflection-specific concerns. This paper presents a systematic investigation on how aspect-oriented programming scales up to improve modularity of typical reflection-specific crosscutting concerns. We have quantitatively compared Java and AspectJ implementations of an OpenORBcompliant reflective middleware using separation of concerns metrics

Context-Aware Exception Handling in Mobile Agent Systems: The MoCA Case

Handling erroneous conditions in context-aware mobile agent systems is challenging due to their intrinsic characteristics: openness, lack of structuring, mobility, asynchrony, and increased unpredictability. Even though several context-aware middleware systems support now the development of mobile agent-based applications, they rarely provide explicit and adequate features for context-aware exception handling. This paper reports our experience in implementing error handling strategies in some prototype context-aware collaborative applications built with the MoCA (Mobile Collaboration Architecture) system. MoCA is a publish-subscribe middleware supporting the development of collaborative mobile applications by incorporating explicit services to empower software agents with context-awareness. We propose a novel context-aware exception handling mechanism and discuss some lessons learned during its integration in the MoCA infrastructure. The discussions include how to use other emerging implementation techniques, such as aspect-oriented programming, to address the limitations of classical publish-subscribe mechanisms identified in our study

Handling Exceptional Conditions in Mobile Collaborative Applications:An Exploratory Case Study

The incorporation of exception handling strategies in mobile collaborative applications bring several challenges to middleware designers due to their intrinsic characteristics of openness, contextawareness, lack of structuring, asynchrony, and increased unpredictability. Publish-subscribe middleware systems are often referred as one of the most common solutions to support the construction of mobile collaborative applications. However, there is no systematic study dedicated to investigate to what extent publish-subscribe mechanisms provide proper support for introducing exception handling strategies into such mobile systems. This paper presents a case study where we have analyzed: (i) the problems emerging from the incorporation of application-specific error handling in a prototype context-aware mobile system from the health care domain, and (ii) the feasibility of a typical publish-subscribe middleware system, called MoCA, to implement the features of an exception handling mechanism tailored to specific requirements of mobile collaborative applications. This paper also discusses the suitability of existing mechanisms recently proposed in the literature to address the identified shortcomings

Exceptions and aspects: the devil is in the details.

ABSTRACT It is usually assumed that the implementation of exception handling can be better modularized by the use of aspectoriented programming (AOP). However, the trade-offs involved in using AOP with this goal are not well-understood. This paper presents an in-depth study of the adequacy of the AspectJ language for modularizing exception handling code. The study consisted in refactoring existing applications so that the code responsible for implementing heterogeneous error handling strategies was moved to separate aspects. We have performed quantitative assessments of four systemsthree object-oriented and one aspect-oriented -based on four quality attributes, namely separation of concerns, coupling, cohesion, and conciseness. Our investigation also included a multi-perspective analysis of the refactored systems, including (i) the reusability of the aspectized error handling code, (ii) the beneficial and harmful aspectization scenarios, and (iii) the scalability of AOP to aspectize exception handling in the presence of other crosscutting concerns