Embedding Performance Testing in Agile Software Model

In the last couple of decades, the software development process has evolved drastically, starting from Big Bang to Waterfall to Agile. The primary driver for the evolution of the software was the “Speed of Delivery” of the Software Product which has significantly accelerated from months to less than weeks and days. For IT (Information Technology) Organizations to be successful, they inevitably need a strong technology presence to roll out new software and features as quickly as possible to their customer base. The current user generation tends to use technology to maximum potential and is always striving to keep up with the new trends. The main subject is for the organizations to be ready with their Speed of Delivery strategy adapting to all technology modernization initiatives like CICD (Continuous Integration and Continuous Deployment), Agile, DevOps, and Cloud so that there are negligible customer friction and no risks to their Market shares,. The aim of this paper is to compare the performance testing in every stage of the agile model to the traditional end testing. The results of the corresponding testing phases are presented in this paper.

Properties of a Feature in Code-Assets: An Exploratory Study

Software product line engineering is a paradigm for developing a family of software products from a repository of reusable assets rather than developing each individual product from scratch. In featureoriented software product line engineering, the common and the variable characteristics of the products are expressed in terms of features. Using software product line engineering approach, software products are produced en masse by means of two engineering phases: (i) Domain Engineering and, (ii) Application Engineering. At the domain engineering phase, reusable assets are developed with variation points where variant features may be bound for each of the diverse products. At the application engineering phase, individual and customized products are developed from the reusable assets. Ideally, the reusable assets should be adaptable with less effort to support additional variations (features) that were not planned beforehand in order to increase the usage context of SPL as a result of expanding markets or when a new usage context of software product line emerges. This paper presents an exploration research to investigate the properties of features, in the code-asset implemented using Object-Oriented Programming Style. In the exploration, we observed that program elements of disparate features formed unions as well as intersections that may affect modifiability of the code-assets. The implication of this research to practice is that an unstable product line and with the tendency of emerging variations should aim for techniques that limit the number of intersections between program elements of different features. Similarly, the implication of the observation to research is that there should be subsequent investigations using multiple case studies in different software domains and programming styles to improve the understanding of the findings.

A Framework for Aspectual Requirements Validation: an Experimental Study

Requirements engineering is a discipline of software engineering that is concerned with the identification and handling of user and system requirements. Aspect-Oriented Requirements Engineering (AORE) extends the existing requirements engineering approaches to cope with the issue of tangling and scattering resulted from crosscutting concerns. Crosscutting concerns are considered as potential aspects and can lead to the phenomena “tyranny of the dominant decomposition”. Requirements-level aspects are responsible for producing scattered and tangled descriptions of requirements in the requirements document. Validation of requirements artefacts is an essential task in software development. This task ensures that requirements are correct and valid in terms of completeness and consistency, hence, reducing the development cost, maintenance and establish an approximately correct estimate of effort and completion time of the project. In this paper, we present a validation framework to validate the aspectual requirements and the crosscutting relationship of concerns that are resulted from the requirements engineering phase. The proposed framework comprises a high-level and low-level validation to implement on software requirements specification (SRS). The high-level validation validates the concerns with stakeholders, whereas the low-level validation validates the aspectual requirement by requirements engineers and analysts using a checklist. The approach has been evaluated using an experimental study on two AORE approaches. The approaches are viewpoint-based called AORE with ArCaDe and lexical analysis based on Theme/Doc approach. The results obtained from the study demonstrate that the proposed framework is an effective validation model for AORE artefacts.

Product Quality Evaluation Method (PQEM): To Understand the Evolution of Quality Through the Iterations of a Software Product

Promoting quality within the context of agile software development, it is extremely important as well as useful to improve not only the knowledge and decision-making of project managers, product owners, and quality assurance leaders but also to support the communication between teams. In this context, quality needs to be visible in a synthetic and intuitive way in order to facilitate the decision of accepting or rejecting each iteration within the software life cycle. This article introduces a novel solution called Product Quality Evaluation Method (PQEM) which can be used to evaluate a set of quality characteristics for each iteration within a software product life cycle. PQEM is based on the Goal-Question-Metric approach, the standard ISO/IEC 25010, and the extension made of testing coverage in order to obtain the quality coverage of each quality characteristic. The outcome of PQEM is a unique multidimensional value, that represents the quality level reached by each iteration of a product, as an aggregated measure. Even though a value it is not the regular idea of measuring quality, we believe that it can be useful to use this value to easily understand the quality level of each iteration. An illustrative example of the PQEM method was carried out with two iterations from a web and mobile application, within the healthcare environment. A single measure makes it possible to observe the evolution of the level of quality reached in the evolution of the product through the iterations.

Enhancing Delphi Method with Algorithmic Estimates for Software Effort Estimation: An Experimental Study

Literature review shows that more accurate software effort and cost estimation methods are needed for software project management success. Expert judgment and algorithmic model estimation are two predominant methods discussed in the literature. Both are reported almost at the comparable level of accuracy performance. The combination of the two methods is suggested to increase the estimation accuracy. Delphi method is an encouraging structured expert judgment method for software effort group estimation but surprisingly little was reported in the literature. The objective of this study is to test if the Delphi estimates will be more accurate if the participants in the Delphi process are exposed to the algorithmic estimates. A Delphi experiment where the participants in the Delphi process were exposed to three algorithmic estimates –Function Points, COCOMO estimates, and Use Case Points, was therefore conducted. The findings show that the Delphi estimates are slightly more accurate than the statistical combination of individual expert estimates, but they are not statistically significant. However, the Delphi estimates are statistically significant more accurate than the individual estimates. The results also show that the Delphi estimates are slightly less optimistic than the statistical combination of individual expert estimates but they are not statistically significant either. The adapted Delphi experiment shows a promising technique for improving the software cost estimation accuracy.

Modeling and Verification of ERP Functional Requirements based on Colored Petri Net

The rise of enterprise resource planning (ERP) systems has been a major event in the software industry and it became a solution for most enterprises to manage their data and business processes. Successful ERP implementations can reduce costs by improving efficiency then lead to improved company performance and better competitive edge. Despite these benefits and the age of ERP existing for several decades still high percentage of implementation failures are documented. ERP is packaged software designed by following the best practice from the specific industry to support typical business processes in the entire industrial field, it was designed by ERP vendors and used by the organization which implement it. Since the designer and user are two independent entity misalignments between user’s needs and the software design are often happen. The misalignment define new specific requirements must be embedded into selected ERP. Requirement engineering (RE) is a main part and initial activity of software engineering concern about defines stakeholder requirements, needs and desire. Requirements engineering is the basis for efficient software implementation and quality management. Tools and theories which support RE in general are numerous nowadays; however, the task of providing a tools and theories that specializes in Requirements engineering for Enterprise resource planning systems has been addressed rarely. For that; this paper discusses modelling and verification of ERP functional requirements based on colored Petri nets (CPN) after evaluation of different Business process modelling techniques by using analytical hierarchy process (AHP). CPN considered one of powerful business process modelling techniques and using it help in stakeholder involvement and appropriate organization’s business process representation. The nature of colored Petri nets that help in verification of internal completeness and consistency of ERP functional requirements model.

Embedding Quality into Software Product Line Variability Artifacts

The success of any software product line development project is closely tied to its domain variability management. Whereas a lot of effort has been put into functional variability management by the SPL community, non-functional variability is considered implicit. The result has been dissatisfaction among clients due to resultant poor quality systems. This work presents an integrated requirement specification template for quality and functional requirements at software product line variation points. The implementation of this approach at the analytical description phase increases the visibility of quality requirements obliging developers to implement them. The approach proposes the use of decision tree classification techniques to support the weaving of functional quality attributes at respective variation points. This work, therefore, promotes software product line variability management objectives by proposing new functional quality artifacts during requirements specification phase. The approach is illustrated with an exemplar mobile phone family data storage requirements case study.

Predefined Project Scope Changes and its Causes for Project Success

In project management, the project scope is the base of significant project planning processes such as estimating the cost, schedule and building work breakdown structure. Poor project scope definition directly affects project cost and schedule. Accordingly, dealing with unrealistic scope definition of cost and schedule may lead to failing a project. Besides, changes in project scope have a negative and positive impact on project success. This paper aims to predefine the potential scope changes to keep the project scope on track and identify any weakness in scope definition at the early stages of a project. Enhancing project scope quality has a massive impact on the success of a project and it adds more control over project scope. A method is proposed to improve the quality of project scope and increase the efficiency of controlling scope changes. The proposed method will help to avoid scope creeping by defining a clear statement of work, increase the learning opportunities of the development team to optimize its processes, reducing the communication gap between the clients and development team and screen adjustments of new tasks. The proposed method is validated using a survey and the results are found encouraging.

A Holistic Self-Adaptive Software Model

The recent self-adaptive software systematic literature reviews stated clearly the following insufficiencies: (1) the need for a holistic self-adaptive software model to integrate its different aspects (2) The limitation of adaptations to context changes (3) The absence of a general and complete adaptations’ picture allowing its understandability, maintainability, evaluation, reuse, and variability. (4) The need for an explicit and a detailed link with resources, and (5) a usual limitation to known events. In order to metigate these insufficiencies, this paper is proposing a holistic model that integrates the operating, adaptations, and adaptations’ manager aspects. The proposed model covers all possible adaptations: operating (dealing with software functions failures), lifecycle (handling adaptations required by some software lifecycle steps), and context (facing context changes events). The presented work introduces the concept of software adaptations process integrating the specifications of all the above kind of adaptations. In fact, this work shows an explicit trace to its pure bio-inspired origin.An application of the proposed approach on a “car industry case study” demonstrated its feasibility in comparison with similar works that proved its meaningful added value and its promising research perspectives.

Generating Software Product Line Model by Resolving Code Smells in the Products’ Source Code

Software Product Lines (SPLs) refer to some software engineering methods, tools and techniques for creating a collection of similar software systems from a shared set of software assets using a common means of production. This concept is recognized as a successful approach to reuse in software development. Its purpose is to reduce production costs by reusing existing features and managing the variability between the different products with respect of particular constraints. Software Product Line engineering is the production process in product lines and the development of a family of systems by reusing core assets. It exploits the commonalities between software products and preserves the ability to vary the functionalities and features between these products. The adopted strategy for building SPL can be a top-down or bottom-up. Depending from the selected strategy, it is possible to face an inappropriate implementation in the SPL Model or the derived products during this process. The code can contain code smells or code anomalies. Code smells are considered as problems in source code which can have an impact on the quality of the derived products of an SPL. The same problem can be present in many derived products from an SPL due to reuse or in the obtained product line when the bottom-up strategy is selected. A possible solution to this problem can be the refactoring which can improve the internal structure of source code without altering external behavior. This paper proposes an approach for building SPL from source code using the bottom-up strategy. Its purpose is to reduce code smells in the obtained SPL using refactoring source code. This approach proposes a possible solution using reverse engineering to obtain the feature model of the SPL.