M.A. de Miguel

Integration of safety analysis in model-driven software development

Safety critical software requires integrating verification techniques in software development methods. Software architectures must guarantee that developed systems will meet safety requirements and safety analyses are frequently used in the assessment. Safety engineers and software architects must reach a common understanding on an optimal architecture from both perspectives. Currently both groups of engineers apply different modelling techniques and languages: safety analysis models and software modelling languages. The solutions proposed seek to integrate both domains coupling the languages of each domain. It constitutes a sound example of the use of language engineering to improve efficiency in a software-related domain. A model-driven development approach and the use of a platform-independent language are used to bridge the gap between safety analyses (failure mode effects and criticality analysis and fault tree analysis) and software development languages (e.g. unified modelling language). Language abstract syntaxes (metamodels), profiles, language mappings (model transformations) and language refinements, support the direct application of safety analysis to software architectures for the verification of safety requirements. Model consistency and the possibility of automation are found among the benefits.

Integration of QoS facilities into component container architectures

Component-based infrastructures 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 do not integrate facilities to support these types of problems and include limitations of predictability and dependability. These infrastructures are designed to provide support to financial and e-commerce applications; they integrate as basic services the transaction, persistence, security and events. These are useful services in real-time and telecom applications, but these applications require other types of services to provide predictability and reliability. We introduce some practical solutions to integrate QoS (Quality of Service) services in the component infrastructures and the results that their business components can expect.Component-based infrastructures 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 do not integrate facilities to support these types of problems and include limitations of predictability and dependability. These infrastructures are designed to provide support to financial and e-commerce applications; they integrate as basic services the transaction, persistence, security and events. These are useful services in real-time and telecom applications, but these applications require other types of services to provide predictability and reliability. We introduce some practical solutions to integrate QoS (Quality of Service) services in the component infrastructures and the results that their business components can expect.

Solutions to make Java-RMI time predictable

Java-RMI is a well-known distribution middleware framework that allows the invocation of remote methods. The paper describes the extension of Java-RMI model to make the remote method calls time predictable. We identify the problems of the jdk implementation of RMI and propose solutions to implement the Java-RMI extended model. This extended model and the proposed solutions are based on the Java and CORBA real-time extensions and especially on network resource reservation protocols. These extensions provide services for the network resource negotiation and to limit the latency of RMI services. The proposed solutions can be integrated in jdkl.2 RMI implementation, using the Java real time package and RSVP implementations.

Two alternative RMI models for real-time distributed applications

Javas popularity, facilities and platform independence have made it an interesting language for the real time community. The RTSJ (real-time specification for Java) is a Java extension to allow the development of real-time systems. RTSJ does not supply any support for the development of real-time distributed systems. The goal of this work is to define support for this type of systems, based on RMI (remote method invocation). However, the high diversity of real-time systems implies that there is not a single RT-RMI definition that satisfies their requirements. This article presents the basics of two real-time RMI approaches: safety critical RMI, to support hard real-time and high integrity requirements, and quality of service RMI for soft real-time systems, which is based on resource reservation to provide some minimal required quality.

Predictable Serialization in Java

RTSJ (Real-Time Specification for Java) extends and adapts the Java technology in order to allow the development of real time systems. In RTSJ the requirements of distributed systems were not considered. The serialization in Java is an example of a basic operation that needs to be reviewed to make distributed Java fully predictable and suitable for hard-real time systems. However, the most recent works in the application of Java in distributed real-time systems do not specify how a serialization process must be used in order to obtain a deterministic behavior. This paper describes a new serialization process focused on hard real-time systems which provide full time and space predictability

Object-oriented design of real-time systems with stereotypes

Real time systems have inherent complexity that makes them difficult to build. Object oriented techniques, which have been shown to be an effective means of tackling complexity in other areas of software engineering, have some problems when applied to real time systems design. We identify some of these problems, and describe some ways of dealing with them in an integrated framework including behavioral specifications and schedulability analysis.

General framework for the description of QoS in UML

UML is useful for modeling object-oriented systems, their behavior and interaction. However, UML currently does not support the modeling of quality of service (QoS) criteria, such as the reliability and accuracy (i.e., quality). A QoS framework provides support to ensure consistency in modeling various qualities of service. It supports a general categorization of different kinds of QoS; including QoS that are fixed at design time as well as ones that are managed dynamically. And it supports the integration of different categories of QoS for the purpose of QoS modeling of system aspects. Frequently the behavior of a system component is functionally correct, but the result it generates is nevertheless unacceptable because the result does not meet some QoS criteria. One way to enhance the capability of the system to deliver results of acceptable quality is to use flexible components that adapt their behavior depending on the resources available and the QoS required.

Animation of heterogeneous prototypes of real-time systems

The rapid advance of hardware and software technologies has led to a continuous increment in the complexity of real-time systems. On the other side, requirements of these systems are increasingly stringent: more functionality with less resources, and in less time. The main weapons to manage the development of RTS are methodologies based on risks reduction and life cycles steps integration. This article presents a toolset that supports heterogeneous prototyping. This technique relies upon the development of evolutionary models of the system, whose parts are built at different speeds, the higher risk part being developed first. The toolset allows the execution and validation of a global model of the system under development, in which some parts are still at the specification or design stage while others have been already fully implemented. The internal architecture of the tools is shown, and their use for validation through animation of heterogeneous prototypes is pointed out. All concepts are applied to a small example.

Model Based Development of Quality-Aware Software Services

Modelling languages and development frameworks give support for functional and structural description of software architectures. But quality-aware applications require languages which allow expressing QoS as a first-class concept during architecture design and service composition, and to extend existing tools and infrastructures adding support for modelling, evaluating, managing and monitoring QoS aspects. In addition to its functional behaviour and internal structure, the developer of each service must consider the fulfilment of its quality requirements. If the service is flexible, the output quality depends both on input quality and available resources (e.g., amounts of CPU execution time and memory). From the software engineering point of view, modelling of quality-aware requirements and architectures require modelling support for the description of quality concepts, support for the analysis of quality properties (e.g. model checking and consistencies of quality constraints, assembly of quality), tool support for the transition from quality requirements to quality-aware architectures, and from quality-aware architecture to service run-time infrastructures. Quality management in run-time service infrastructures must give support for handling quality concepts dynamically. QoS-aware modeling frameworks and QoS-aware runtime management infrastructures require a common evolution to get their integration.

Modeling Quality of Service Adaptability

Quality of service adaptability refers to the ability of services (or components) to adapt the quality exhibited during run-time, or to the faculty of architectural models to show that several alternatives concerning quality could be implemented. Enclosing quality properties with architectural models has been typically used to improve system understanding. Nevertheless, these properties can also be used to compose subsystems whose quality can be adapted or/and to predict the behavior of the run-time adaptability. Existing software modeling languages lack enough mechanisms to cope with adaptability, e.g. to describe software elements that may offer/require several quality levels. This paper presents concepts that such a language needs to include to model quality-adaptable systems, and how we use those concepts to compose and analyze software architectures.