Rosana T. V. Braga

Adapting a software product line engineering process for certifying safety critical embedded systems

Software Product Line Engineering (SPLE) is a software development paradigm that aims at reducing the development effort and shorting time-to-market through systematic software reuse. While this paradigm has been successfully applied for the development of embedded systems in various domains, new challenges have emerged from the development of safety critical systems that require certification against a specific standard. Existing SPLE approaches do not explicitly consider the various certification standards or levels that products should satisfy. In this paper, we focus on several practical issues involved in the SPLE process, establishing an infrastructure of a product line engineering for certified products. A metamodel is proposed to capture the entities involved in SPL certification and the relationships among them. ProLiCES, which is a model-driven process for the development of SPLs, was modified to serve as an example of our approach, in the context of the UAV (Unmanned Aerial Vehicle) domain.

Legacy systems reengineering using software patterns

We present a case study for legacy systems reengineering using software patterns, aiming at both easing the reengineering process and improving future maintenance. The approach used consists basically of three steps: apply reverse engineering if necessary, to obtain an object model of the system; recognize software patterns present in the object model obtained; and re-implement the system in a more productive way, using toolkits or specific frameworks that implement the patterns found. Results of some experiments show that reengineering has been facilitated as well as system maintenance, because components became clearly delimited and larger chunks of design may now be understood as a whole and reused.

Building a Wizard for Framework Instantiation Based on a Pattern Language

Pattern languages can be used to guide the construction and instantiation of object-oriented frameworks. A process for building a wizard to automatically instantiate applications from a framework built based on a pattern language is described in this paper. The main goal of this wizard is to generate all the code needed to instantiate the framework to a particular system, based on information about the patterns of the pattern language applied to model a particular system, together with additional attributes included in the classes that compose each pattern. The proposed process is illustrated with the GREN-Wizard, a tool to instantiate the GREN framework to particular systems in the business resource management domain. GREN was built based on a pattern language for the same domain, called GRN, which is used during the instantiation process.

Incorporating certification in feature modelling of an unmanned aerial vehicle product line

Safety critical systems (e.g., an avionics control system for safe flight) are often required to achieve certification under pre-established standards (e.g., DO-178B for software considerations in airborne systems and equipment certification). We have been working with our industrial partner for the last three years to develop product line assets for their avionics software product line (SPL) and, recently, we encountered two major challenges regarding certification. Firstly, an individual product must be certified, but each may require a different certification level: there might be variations in the certification requirements according to specific system usage contexts. Secondly, certification involves not only product but also process, as standards such as DO-178B also assess the quality of the development process. In this paper, we propose to include a certification view during feature modelling to provide a better understanding of the relationships between features and a certification level required for each product. The experience of introducing certification into the design model of an Unmanned Aerial Vehicle (UAV) SPL is presented to illustrate some key ideas. We also describe the lessons we have learned from this experience.

Reengineering of legacy systems based on transformation using the object oriented paradigm

Legacy systems that were originally developed using the procedure-oriented approach can be reengineered according to the object-oriented paradigm by the process proposed in this paper. Three phases are included in such a process: an object oriented reverse engineering phase, in which an object oriented analysis model of the legacy system is produced by Fusion/RE; a segmentation phase, in which the original code is segmented into object oriented methods, keeping the procedural language; and finally a transformation phase, in which the segmented code is transformed to an object oriented language by the Draco-Puc machine. The application of this process to a real mechanic and electric car repair shop system, with 20000 lines of source code, is described. Samples of the Java code obtained by transforming the original Clipper code are supplied.

A process for framework construction based on a pattern language

A process for building an object-oriented framework based on a pattern language, both for the same domain, is proposed. This process includes several activities, as the identification of the framework hot-spots, the framework design, implementation, and validation. All these activities are supported by the pattern language. Besides that, by using the process here proposed, the resulting framework is implicitly documented by the pattern language. This makes it easier for the developer to instantiate applications, as the knowledge about the pattern language is used during the instantiation process.

Reengineering using design patterns

Starting from a legacy system, originally developed in C and using text files, we first conducted a reverse engineering of this system to obtain its object-oriented analysis model. Then, in a process that is called segmentation, we restructured the code, changing all data structures to abstract data types and procedures to methods, eliminating all data access anomalies. This paper presents an experiment in which part of the segmented code was reengineered to an object-oriented language (Java) and the text files were replaced by a relational database. We show how design patterns have been used to link the database with the object-oriented concepts of Java. We also report a maintenance experiment that compares maintainability of the legacy system, the segmented system, and the object-oriented version.

Development of Critical Embedded Systems Using Model-Driven and Product Lines Techniques: A Systematic Review

Several methodologies have been proposed in the last decades to improve the quality of Safety-Critical Embedded Systems (SCES) and, at the same time, keep costs and schedule compatible with project plans. In particular, approaches such as Product Line Engineering (PLE) and Model-Driven Engineering (MDE) offer an interesting solution to reduce development complexity and time to market due to their synergy and common goals. However, the current state of how MDE and PLE can be combined to enhance productivity in the domain of SCES is not clear yet. This paper presents a systematic literature review, with the purpose of obtaining the state of the art of the aproaches, methods and methodologies whose goal is the combination of PLE and MDE for the development of SCES, and to verify the existence of empirical studies that demonstrate the application of these techniques in this type of development. We drew the following conclusions from the review results: (1) The number of studies using PLE with MDE to build SCES is relatively small, but has increased gradually in recent years. (2) The approaches diverge about what is needed to build Model-driven Product Lines. (3) Most of the approaches do not consider to differentiate between hardware and software variabilities. (4) Most of the studies propose the use of UML and feature diagrams. (5) The studies present case studies implemented in different tools and most of them are free. (6) The approaches do not cover the entire development lifecycle.

Assessment of product derivation tools in the evolution of software product lines: an empirical study

Product derivation approaches automate the customization process of software product lines. Over the last years, many tools have been proposed aiming at synthesize and generate products from a set of reusable assets. These tools adopt different techniques and strategies to implement and automate the product derivation activities. In this paper, we analyzed six modern product derivation tools (Captor, CIDE, GenArch, MSVCM, pure::variants, XVCL) in the context of evolution scenarios of a software product line. Our study has adopted several metrics to analyze the modularity, complexity and stability of product derivation artifacts related to configuration knowledge along different releases of a mobile product line. The preliminary results of our study have shown that approaches with a dedicated model or file to represent the CK specification can bring several benefits to the modularization and stability of a software product line.

Finding Frameworks Hot Spots in Pattern Languages

An important issue that contributes to the complexity of object-oriented framework development is the identification of its hot spots, i.e., the framework parts that must be kept flexible, as they are specific of individual systems. A process for identification of hot spots in an analysis pattern language is proposed. Several types of hot spots are identifiable from information presented in the elements of each pattern of the pattern language, making possible to define a process to sistematize this task. An example illustrates the hot spots identification based on a pattern language for business resource management.