A. de Miguel

Practical Experiences in the Application of MDA

During the last ten years a lot of concepts have emerged from software engineering. Most of them try to formalize and organize software engineering knowledge at a higher level of abstraction, giving code a secondary role. Model Driven Architecture (MDA), putting the concept of the model on the critical path of software development, is about to change this situation, turning the role of models from contemplative to productive. This paper introduces some problems detected in the process of adoption of MDA methods. The application of MDA for a specific domain, technique, or technology requires the Description of Specialized Modeling Language. Two main techniques provide support for the description of UML extensions, MOF meta-models and UML profiles. The Process of Mapping Description requires good support to identify the elements of the source modeling language that are mapped and the model elements of the destination modeling language that correspond to the source elements. This process require specific solutions.

RMI-HRT: remote method invocation - hard real time

Real time systems have a great impact in areas such as: telecommunications, consumer electronics, medical equipment, etc. Additionally, the Java community has defined RTSJ (Real Time Specification for Java) for the development of these systems with Java technology. RTSJ introduces new memory areas to avoid the effect of the garbage collector, improves the scheduling of threads, and provides mechanisms for the asynchronous transfer of control, and protocols to bind the priority inversion, etc. However, RTSJ does not include facilities to develop distributed applications. This is an important limitation that reduces the usage of RTSJ. As a consequence, RMI-HRT (Remote Method Invocation - Hard Real Time) has been developed in the context of the HIJA (High-Integrity Java Applications) project to provide support for distributed applications which are targeted at safety-critical applications. The objective of this paper is to show the most important aspect of RMI-HRT.

Automatic Generation of Simulation Models for the Evaluation of Performance and Reliability of Architectures Specified in UML

Non-functional requirements are especially critical in real-time and distributed systems. UML is progressively becoming a standard of object-oriented analysis and design of systems, it pays attention to software architectures specification, but it does not take into account their evaluation, and the specification of resource restrictions and non-functional requirements. In this paper we introduce an approach for the evaluation of non-functional requirements in UML models, using simulation techniques. Simulation models are generated automatically, and their execution provides results to evaluate the UML architectures. The simulation statistics generated allow the evaluation of some non-functional requirements like resources usage, objects and classes activity and availability, restoration times of errors and throughputs. We associate these results to objects, classes, states, operations, actors, system resources and other UML elements. UML semiformal semantics have associated problems that we reduce with UML extension techniques.

Container Model Based on RTSJ Services

The container is a basic structure of J2EE used to reduce the complexity of clients and applicative services. Component-based infrastructures use this type of structures and provide support for the development and execution of component-based systems. However, they have limitations in their application in real-time and reliable systems, because they neither integrate facilities to support these types of problems nor include services of predictability and dependability. RTSJ is a basic framework that includes the basic services for the construction of Java real-time systems. The combination of both Java approaches (Containers and RTSJ) is a good solution to reduce the complexity of real-time Java programs. The integration requires the adaptation of both approaches. In this paper we introduce a new model of component container that integrate the RTSJ services based on a resource reservation model.

Quality of Service Composition and Adaptability of Software Architectures

Quality of service adaptability refers to the ability of components/services to adapt in run-time the quality exhibited. A composition study from a quality point of view would investigate how these adaptable elements could be combined to meet system’s quality requirements. Enclosing quality properties with architectural models has been typically used to improve system understanding. Nevertheless these properties along with some supplementary information about quality adaptation would allow us to carry out a composition study during the design phase and even to predict some features of the adaptability behavior of the system. Existing modeling languages and tools lack enough mechanisms to cope with adaptability, e.g. to describe system elements that may offer/require several quality levels. This paper shows how we reuse existing modeling languages and tools, combine them and create new ones to tackle the problem of quality of service adaptability and composition. The final goal of this work is to evaluate architectural models to predict system’s QoS behavior before it is implemented.

Application of safety analyses in model driven development

Some high integrity software systems require the rigorous validation of safety properties. Assessing whether software architectures are able to meet these requirements is of great interest: to avoid the risk that the implementation does not fulfill requirements due to a bad design, and, to reduce the development cost of safety critical parts of the system. Safety analyses like FMECA and FTA are two methods used during preliminary safety assessments. We have implemented tools to automatically generate safety analyses from the models of the architecture: a UML profile for safety, modeling languages to express safety analyses, and a model transformation chain. Safety analysts can use these tools to annotate the models, analyze the architecture, and recommend system engineers mitigation means to apply for improving the architecture.

A Model-Based Framework for Developing Real-Time Safety Ada Systems

This paper describes an MDE framework for real-time systems with safety requirements. The framework is based on industry standards, such as UML 2.2, MARTE, and the Ada Ravenscar profile. It integrates pre-existing technology with newly developed tools. Special care has been taken to ensure consistency between models and final code. Temporal analysis is integrated in the framework in order to ensure that the real-time behaviour of the models and the final code is consistent and according to the specification.

Early Validation of Real-Time Systems by Model Execution

Abstract The late validation of temporal aspects is still today the great bottleneck in embedded real-time systems (ERTS) development. In this article, a twofold approach is presented to reduce this problem: to enhance the visibility of temporal aspects in the product through the use of the proper design notations and models, and to integrate these notations with tools that allow the validation in a stage previous to coding. Both tools and notations allow the early feedback of functional and timing behavior, provide automatic support for the validation, and reduce the conceptual distance between the system specification and its implementation.

Model-based development for RTSJ platforms

The integration of real-time concepts into modeling tools and Java virtual machines and APIs are two problems addressed along last decade. Examples of standards addressing these problems are RTSJ (Real-Time Specification for Java) and MARTE (Modeling and Analysis of Real-time Embedded Systems). These standards, in general, have common fundaments (time predictability of software systems based on scheduling analysis methods and object-oriented languages). Model driven developments methods are based on the application of generators and transformations, on source models, to generate code and artifacts of specific run-time platforms. Common fundaments of RTSJ and MARTE make possible their integration in a common model-driven software development framework. But this integration requires the developments of generators and transformations, and the customizations of UML extensions for the specific run-time platform. Integration of UML profiles into code generations requires specific customizations of generators. This paper studies these problems and proposes solutions for the application of model driven development techniques to develop of RTSJ software systems.

Domain-Specific multi-modeling of security concerns in service-oriented architectures

As a common reference for many in-development standards and execution frameworks, special attention is being paid to Service-Oriented Architectures. SOAs modeling, however, is an area in which a consensus has not being achieved. Currently, standardization organizations are defining proposals to offer a solution to this problem. Nevertheless, until very recently, non-functional aspects of services have not been considered for standardization processes. In particular, there exists a lack of a design solution that permits an independent development of the functional and non-functional concerns of SOAs, allowing that each concern be addressed in a convenient manner in early stages of the development, in a way that could guarantee the quality of this type of systems. This paper, leveraging on previous work, presents an approach to integrate security-related non-functional aspects (such as confidentiality, integrity, and access control) in the development of services.