DYNAMIC DETECTION OF DESIGN INCONSISTENCY DURING SOFTWARE DEVELOPMENT USING DAID APPROACH

Evolution of software has lead to the fast growth of technology whose impact can be witnessed in all the domains of scientific and engineering applications. Hence engineering high quality software is one of the core challenges of all IT industries. The software models which are being used for the development of the software products may lead to inconsistencies. Nevertheless, theexistence of several methodologies during the development process in order to overcome inconsistencies operates at static mode leading towards expensive nature of rework on those inconsistencies. Therefore, this paper presents a dynamic model which resolves the aforementioned issue by capturing inconsistencies dynamically in an automated mode using Dynamic automated inconsistency detection (DAID) model. The implementation results of DAID capture the design inconsistencies dynamically at the time of their injection points in lieu of inconsistency detection during validation testing. This approach of dynamic design inconsistency detection reduces cost, time and its associated overheads. Further implementation of DAID in an automated mode increases productivity, quality and sustainability in IT industries

MEReq: A Tool to Capture and Validate Multi-Lingual Requirements

Within the era of globalisation that acknowledges differences and diversity, multiple languages have been increasingly used to capture requirements. This practice is particularly prevalent in Malaysia, where both Malay and English languages are used as a media of communication. Nevertheless, capturing requirements in multiple languages is often error-prone due to natural language imprecision being compounded by language differences. Considering that two languages may be used to describe requirements for the same system in different ways, we were motivated to develop MEReq, a tool which uses Essential Use Case (EUC) models to support capturing and checking the inconsistency occurring in English and Malay multi-lingual requirements. MEReq is tablet compatible to minimise time for on-site capture and validation of multi-lingual requirements. This paper describes the MEReq approach and demonstrates its use to capture and validate English and Malay requirements

Adapting integrity checking techniques for concurrent operation executions

One challenge for achieving executable models is preserving the integrity of the data. That is, given a structural model describing the constraints that the data should satisfy, and a behavioral model describing the operations that might change the data, the integrity checking problem consists in ensuring that, after executing the modeled operations, none of the specified constraints is violated. A multitude of techniques have been presented so far to solve the integrity checking problem. However, to the best of our knowledge, all of them assume that operations are not executed concurrently. As we are going to see, concurrent operation executions might lead to violations not detected by these techniques. In this paper, we present a technique for detecting and serializing those operations that can cause a constraint violation when executed concurrently , so that, previous incremental techniques, exploiting our approach, can be safely applied in systems with concurrent operation executions guaranteeing the integrity of the data.Peer ReviewedPostprint (author's final draft

FDDetector: A Tool for Deduplicating Features in Software Product Lines

Duplication is one of the model defects that affect software product lines during their evolution. Many approaches have been proposed to deal with duplication in code level while duplication in features hasn’t received big interest in literature. At the aim of reducing maintenance cost and improving product quality in an early stage of a product line, we have proposed in previous work a tool support based on a conceptual framework. The main objective of this tool called FDDetector is to detect and correct duplication in product line models. In this paper, we recall the motivation behind creating a solution for feature deduplication and we present progress done in the design and implementation of FDDetector

Incremental checking of OCL constraints through SQL queries

We propose a new method for efficiently checking OCL constraints by means of SQL queries. That is, an OCL constraint is satisfied if its corresponding SQL query returns the empty set. Such queries are computed in an incremental way since, whenever a change in the data occurs, only the constraints that may be violated because of such change are checked and only the relevant values given by the change are taken into account. Moreover, the queries we generate do not contain nested subqueries nor procedures. In this way, we take advantage of relational DBMS capabilities and we get an efficient check of OCL constraints.Postprint (published version

Computing repairs for constraint violations in UML/OCL conceptual schemas

Updating the contents of an information base may violate some of the constraints defined over the schema. The classical way to deal with this problem has been to reject the requested update when its application would lead to some constraint violation. We follow here an alternative approach aimed at automatically computing the repairs of an update, i.e., the minimum additional changes that, when applied together with the requested update, bring the information base to a new state where all constraints are satisfied. Our approach is independent of the language used to define the schema and the constraints, since it is based on a logic formalization of both, although we apply it to UML and OCL because they are widely used in the conceptual modeling community. Our method can be used for maintaining the consistency of an information base after the application of some update, and also for dealing with the problem of fixing up non-executable operations. The fragment of OCL that we use to define the constraints has the same expressiveness as relational algebra and we also identify a subset of it which provides some nice properties in the repair-computation process. Experiments are conducted to analyze the efficiency of our approach.Peer ReviewedPostprint (author's final draft

Model Defects in Evolving Software Product Lines: A Review of Literature

Software products lines (SPLs) are long living systems that undergo several evolutions throughout their lifetime due to many reasons related to technology, strategy, business, etc. These evolutions can be the source of several defects that impact the different artefacts of SPLs, namely requirements, models, architecture and code. Many studies in the literature have dealt with the correction of defects in software product lines, but to our knowledge, no reviews have been carried out to provide an extensive overview of these studies. In this paper, we present a literature review of model defects in software product lines. The purpose of this review is to enumerate the different defects discussed in literature and to present the approaches proposed to detect and correct them. The findings of this review reveal new research leads to explore in this issue

Incremental Consistency Checking of Dynamic Constraints

Abstract. Software design models are routinely adapted to domains, companies, and applications. This requires customizable consistency checkers that allow engineers to dynamically adapt model constraints. To benefit from quick design feedback, such consistency checkers should evaluate the consistency of such changeable constraints incrementally with design changes. This paper presents such a freely customizable, incremental consistency checker. We demonstrate that constraints can be defined and re-defined at will. And we demonstrate that its performance is instant for many kinds of constraints without manual annotations or restrictions on the constraint language used. Our approach supports both model and meta-model constraints and was evaluated on over 20 software models and 24 types of constraints. It is fully automated and integrated into the IBM Rational Software Modeler tool