Abstract Safety‐critical systems are of paramount importance for many application domains, where safety properties are a key driver to engineer critical aspects and avoid system failures. For the benefits of large‐scale reuse, software product lines (SPL) have been adopted in critical systems industry. However, the integration of safety analysis in the SPL development process is nontrivial. Also, the different usage contexts of safety‐critical systems complicates component fault modeling tasks and the identification of potential hazards. In this light, better methods become necessary to estimate the impact of dependability properties during Hazard Analysis and Risk Assessment. Existing methods incorporating the analysis of safety properties in SPL are limited as they do not include hazard analysis and component fault modeling. In this paper, we present the novel DEPendable Software Product Line Engineering (DEPendable‐SPLE) approach, which extends traditional SPL processes to support the reuse of safety assets. We also present a detailed analysis of the impact of product and context features on the SPL design, safety analysis, and safety requirements. We applied DEPendable‐SPLE to a realistic case study from the aerospace domain to illustrate how to model and reuse safety properties. DEPendable‐SPLE reduced the effort of safety analysis for certifying system variants.

A product-line architecture (PLA) entails a design reused by a family of products sharing several features. The long-term stability of a PLA largely depends on the modularization of each feature from the design outset. As many features of a product-line crosscut the PLA decomposition, their modularity and stability are often improved with aspect-orientation according to recent studies. However, the use of this technique in proactive design of PLAs is challenging and has rarely been investigated. The problem is that information about the crosscutting nature of features is limited in this case. This paper presents a first study aimed at analyzing the feasibility of deriving stable aspect-oriented PLAs through a proactive design method. Our study relies on a product line and presents an in-depth exploratory analyse. We compare the stability of aspect-oriented and alternative candidates for proactively-designed PLAs. The results indicate that it is possible to derive aspect-oriented PLAs with superior stability based on a proactive design method. In addition, it is possible to anticipate pros and cons of PLAs with aspects when the latter are incorporated at an early design stage.

This paper presents the results of an exploratory study on the fault-proneness of aspect-oriented programs. We analysed the faults collected from three evolving aspect-oriented systems, all from different application domains. The analysis develops from two different angles. Firstly, we measured the impact of the obliviousness property on the fault-proneness of the evaluated systems. The results show that 40% of reported faults were due to the lack of awareness among base code and aspects. The second analysis regarded the fault-proneness of the main aspect-oriented programming (AOP) mechanisms, namely pointcuts, advices and intertype declarations. The results indicate that these mechanisms present similar fault-proneness when we consider both the overall system and concern-specific implementations. Our findings are reinforced by means of statistical tests. In general, this result contradicts the common intuition stating that the use of pointcut languages is the main source of faults in AOP.

Web services are an emerging Service-Oriented Architecture technology to integrate applications using open standards based on XML. Software Engineering tools integration is a promising area since companies adopt different software processes and need different tools on each activity. Software engineers could take advantage of software engineering tools available as web services and create their own workflow for integrating the required tools. In this paper, we propose the development of testing tools designed as web services and discuss the pros and cons of this idea. We developed a web service for structural testing of Java programs called JaBUTiService, which is based on the stand-alone tool JaBUTi. We also present an usage example of this service with the support of a desktop front-end and pre prepared scripts. A set of 62 classes of the library Apache-Commons-BeanUtils was used for this test and the results are discussed.

The goal of aspect-oriented programming is to modularize concerns that tend to tangle with and scatter across multiple modules of software systems. For that purpose, crosscutting behavior implemented as advice is applied to several points of the base program (i.e., join points) using pointcut mechanisms. However, if pointcuts are wrongly defined, advice can be applied to unintended join points, injecting faults into the system. In this paper we propose the use of an integration structural testing approach to identify these unintended join points caused by faulty pointcuts. We present an AspectJ example that shows evidence of the effectiveness of our approach in this context.

We present CodeGenie, a tool that implements a test-driven approachto search and reuse of code available on large-scale coderepositories. While using CodeGenie developers design test cases fora desired feature first, similar to Test-driven Development (TDD).However, instead of implementing the feature as in TDD, CodeGenieautomatically searches for it based on information available in thetests. To check the suitability of the candidate results in thelocal context, each result is automatically woven into thedeveloper's project and tested using the original tests. Thedeveloper can then reuse the most suitable result. Later, reusedcode can also be unwoven from the project as wished. For the codesearching and wrapping facilities, CodeGenie relies on Sourcerer, anInternet-scale source code infrastructure that we have developed

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.

This paper presents a formal definition for HMBS (Hypermedia Model Based on Statecharts). HMBS uses the structure and execution semantics of statecharts to specify both the structural organization and the browsing semantics of hypermedia applications. Statecharts are an extension of finite-state machines and the model is thus a generalization of hypergraph-based hypertext models. Some of the most important features of HMBS are its ability to model hierarchy and synchronization of information; provision of mechanisms for specifying access structures, navigational contexts, access control, multiple tailored versions,and hierarchical views. Analysis of the underlying statechart machine allows verification of page reachability, valid paths, and other properties, thus providing mechanisms to support authors in the development of structured applications.

The establishment of a low-cost, effective testing and validation strategy has been pursued by many researchers at the program level as well as at the specification level. The application of mutation testing for validating specifications based on statecharts is proposed. A mutation operator set for statecharts, one of the crucial points for effectively applying mutation testing is defined; in this scope these operators can be taken as a fault model. We also provide strategies to abstract the statechart components according to different statechart features that may comprise the testing and validation activity aims, providing in this way mechanisms for the establishment of an incremental, hierarchical, mutation-based testing strategy. Implementation and functional aspects of PROTEUM/ST, a tool under development are also presented.

Introduces hypercharts, a novel and effective notation that extends the well-known statechart formalism to make it suitable for the specification of temporal and information synchronization requirements of hypermedia applications. Three new definitions are added: timed history, timed transitions, and a set of synchronization mechanisms. The proposed extensions are based on the major characteristics of some Petri net-based multimedia models, and have their semantics described in terms of conventional statechart models. Therefore, any hyperchart construction can be transformed into a statechart that exhibits the desired behavior, giving hyperchart models the same semantic behavior as statecharts. The new constructs are illustrated using a case study based on a hypermedia-modeling example.

This paper introduces hypercharts, a novel and effective model that extends the well-known statechart formalism to make it suitable for the specification of the temporal and information synchronization requirements of hypermedia applications. Three new definitions are added: timed history, timed transitions and a set of synchronization mechanisms. The proposed extensions are based on the major characteristics of some Petri net based multimedia models, and have their semantics described in the paper in terms of conventional statechart models.

Proposes the application of the mutation analysis criterion in the context of specifications based on finite state machines. The main concepts of finite state machines and mutation analysis are briefly introduced. An experiment is reported which manually applies mutation analysis to a finite state machine modeling a Class 0 ISO transport protocol specification, using two test-sequence generator criteria-the W method and the TT (transition tours) method. The results obtained are presented, and evidences are given that the use of mutation analysis is effective in this context. Finally, the lines of evolution of the work presented in this paper are briefly discussed.>