Fábio M. Costa

The case for reflective middleware

Its flexible and reconfigurable yet simple for programmers to use, notably for building dynamic distributed applications operating on the Net.

Experiments with Reflective Middleware

Middleware platforms have emerged as an effective answer to the requirements of open distributed processing. However, in our opinion, a new engineering approach based on configurability and openess of platform implementations is essential to meet the needs of applications areas such as multimedia, groupware and mobile computing. This paper outlines our architecture for configurable and open middleware platforms, along with a first prototype. The architecture is based on the concept of reflection, the ability for a program to access, reason about and alter its own implementation in a principled way, according to a well-defined Meta-Object Protocol (MOP) [1].

The Design of a Resource-Aware Reflective Middleware Architecture

Middleware has emerged as an important architectural component in supporting distributed applications. With the expanding role of middleware, however, a number of problems are emerging. Most significantly, it is becoming difficult for a single solution to meet the requirements of a range of application domains. Hence, the paper argues that the next generation of middleware platforms should be both configurable and re-configurable. Furthermore, it is claimed that reflection offers a principled means of achieving these goals. The paper then presents an architecture for reflective middleware based on a multi-model approach. The main emphasis of the paper is on resource management within this architecture (accessible through one of the meta-models). Through a number of worked examples, we demonstrate that the approach can support introspection, and fine- and coarse- grained adaptation of the resource management framework. We also illustrate how we can achieve multi-faceted adaptation, spanning multiple meta-models.

The Role of Reflective Middleware in Supporting the Engineering of Dynamic Applications

The increasing complexity of building distributed applications has positioned middleware as a critical part of complex systems. However, current middleware standards do not address properly the highly dynamic and diverse set of requirements posed by important classes of applications, such as those involving multimedia and mobility. It is clear that middleware platforms need to be more flexible and adaptable and we believe that an open engineering approach is an essential requirement. More specifically, we propose the use of object oriented reflection based on a multi-model reflection framework as a principled way to achieve such openness. This leads to middleware that is flexible, adaptable and extensible, and, in consequence, capable of supporting applications with dynamic requirements.

Mechanisms for Leveraging Models at Runtime in Self-adaptive Software

Modern software systems are often required to adapt their behavior at runtime in order to maintain or enhance their utility in dynamic environments. Models at runtime research aims to provide suitable abstractions, techniques, and tools to manage the complexity of adapting software systems at runtime. In this chapter, we discuss challenges associated with developing mechanisms that leverage models at runtime to support runtime software adaptation. Specifically, we discuss challenges associated with developing effective mechanisms for supervising running systems, reasoning about and planning adaptations, maintaining consistency among multiple runtime models, and maintaining fidelity of runtime models with respect to the running system and its environment. We discuss related problems and state-of-the-art mechanisms, and identify open research challenges.

Application execution management on the InteGrade opportunistic grid middleware

The InteGrade project is a multi-university effort to build a novel grid computing middleware based on the opportunistic use of resources belonging to user workstations. The InteGrade middleware currently enables the execution of sequential, bag-of-tasks, and parallel applications that follow the BSP or the MPI programming models. This article presents the lessons learned over the last five years of the InteGrade development and describes the solutions achieved concerning the support for robust application execution. The contributions cover the related fields of application scheduling, execution management, and fault tolerance. We present our solutions, describing their implementation principles and evaluation through the analysis of several experimental results.

Evaluating the impact of PBL and tablet PCs in an algorithms and computer programming course

The introductory undergraduate course on Algorithms and Computer Programming, commonly known as CS1, has always presented a challenge when considering student failure and drop out rates. Despite this, it is acknowledged that this is a foundational course for a large part of the CS curriculum. In this paper we present the results of a project that combines the use of mobile, pen-based, computing technology and Problem-Based Learning in the redesign of an introductory computer programming course. The course redesign focused on the integrated use of tablet PCs to assist in the several activities involved in the use of the PBL method in the classroom. The results show a promising future for the methodology, also pointing to the need for some important adaptations in order to make its use more effective to teach and learn this particular discipline.

Towards Reliable Smart Microgrid Behavior Using Runtime Model Synthesis

The dominant paradigm of centralized power generation, characterized by heavy transmission losses, is being slowly replaced by the smart micro grid, which promises the proliferation of renewable and distributed energy sources. Micro grid reliability is a well established theme as assurance requirements are inherited from the larger smart grid. In this paper we describe how user defined domain-specific micro grid models can be synthesized using runtime model analysis thereby supporting stability in the micro grid plant. This analysis includes model reconciliation which produces a list of model changes that are then interpreted to control the plant via executable control scripts. To demonstrate the efficacy and applicability of our approach, we apply it to a typical scenario in the energy management domain and prove the concept utilizing a smart micro grid prototype test bed.

Model-driven development of DSML execution engines

The combination of domain-specific modeling languages and model-driven engineering techniques hold the promise of a breakthrough in the way applications are developed. By raising the level of abstraction and specializing in building blocks that are familiar in a particular domain, it has the potential to turn domain experts into application developers. Applications are developed as models, which in turn are interpreted at runtime by a specialized execution engine in order to produce the intended behavior. This approach has been successfully applied in different domains, such as communication and smart grid management to execute applications described by models that can be created and changed at runtime. However, each time the approach has to be realized in a different domain, substantial re-implementation has to take place in order to put together an execution engine for the respective DSML. In this paper, we present our work towards a generalization of the approach in the form of a metamodel which captures the domain-independent aspects of runtime model interpretation and allow the definition of domain-specific execution engines.

Synthesizing interpreted domain-specific models to manage smart microgrids

Abstract The increase in prominence of model-driven software development (MDSD) has placed emphasis on the use of domain-specific modeling languages (DSMLs) during the development process. DSMLs allow for domain concepts to be conceptualized and represented at a high level of abstraction. Currently, most DSML models are converted into high-level languages (HLLs) through a series of model-to-model and/or model-to-text transformations before they are executed. An alternative approach for model execution is the interpretation of models directly without converting them into an HLL. These models are created using interpreted DSMLs (i-DSMLs) and realized using a semantic-rich execution engine or domain-specific virtual machine (DSVM). In this article we present an approach for model synthesis, the first stage of model interpretation, that separates the domain-specific knowledge (DSK) from the model of execution (MoE). Previous work on model synthesis tightly couples the DSK and MoE reducing the ability for implementations of the DSVM to be easily reused in other domains. To illustrate how our approach to model synthesis works for i-DSMLs, we have created MGridML, an i-DSML for energy management in smart microgrids, and an MGridVM prototype, the DSVM for MGridML. We evaluated our approach by performing experiments on the model synthesis aspect of MGridVM and comparing the results to a DSVM from the user-centric communication domain.