Non-Functional Requirements Elicitation Guideline for Agile Methods

One of the essential activities in software development is elicitation of requirement. Majority of the studies has pointed out that less attention is given to the NonFunctional Requirement (NFR). The negligence of NFR elicitation is due to lack of knowledge of the user and developer about NFR. Our study presents elicitation guidelines for NFRs in agile methods. This guideline will helps developers as well as users in agile methods. A case study is conducted on the group of master students for eliciting NFR with the help of elicitation guidelines. In addition, the initial results were obtained by extracting NFRs from eProcurement document that carries requirements of major European Union projects. The result of the case study is positive and encouraging for the new developers and users having less awareness about NFRs. Furthermore, the study describes the role of cloud computing in agile methods, especially in elicitation activity

Technique for early reliability prediction of software components using behaviour models

Behaviour models are the most commonly used input for predicting the reliability of a software system at the early design stage. A component behaviour model reveals the structure and behaviour of the component during the execution of system-level functionalities. There are various challenges related to component reliability prediction at the early design stage based on behaviour models. For example, most of the current reliability techniques do not provide fine-grained sequential behaviour models of individual components and fail to consider the loop entry and exit points in the reliability computation. Moreover, some of the current techniques do not tackle the problem of operational data unavailability and the lack of analysis results that can be valuable for software architects at the early design stage. This paper proposes a reliability prediction technique that, pragmatically, synthesizes system behaviour in the form of a state machine, given a set of scenarios and corresponding constraints as input. The state machine is utilized as a base for generating the component-relevant operational data. The state machine is also used as a source for identifying the nodes and edges of a component probabilistic dependency graph (CPDG). Based on the CPDG, a stack-based algorithm is used to compute the reliability. The proposed technique is evaluated by a comparison with existing techniques and the application of sensitivity analysis to a robotic wheelchair system as a case study. The results indicate that the proposed technique is more relevant at the early design stage compared to existing works, and can provide a more realistic and meaningful prediction

An approach for mapping the aspect state models to aspect-oriented code

Model-driven code generation allows rapid generation of precise code thus reducing the development effort and the delivery time. Consequently, model-driven code generation has been a topic of interest in varying perspectives. While model-driven code generation has been explored well in many domains, its full potential has not been exploited in the context of aspect-oriented software development. The existing approaches have mainly focused on code generation from class diagrams only. Code generation from class diagrams is straightforward as majority of the constructs involved in these diagrams are directly mapped to those in programming languages. However, code generated using class diagrams is limited to skeletons of classes and methods only and does not contain behavior. In this study, we use the state diagrams and propose a mapping of its constructs to AspectJ language. We use the Reusable Aspect Models notation for this purpose. The approach addresses the mapping of both structure and behavior, however, owing to their strength with respect to modeling the system behavior, it essentially focuses on the state diagrams encapsulated in these models. A detailed mapping of different features of the state diagrams is proposed. The approach is illustrated by means of aspect models and corresponding mapped code from an aspect-oriented implementation of a Remote Service Caller example. The implementation shows that the approach can effectively be applied to obtain code for complete structure and behavior modeled using Reusable Aspect Models

A hybrid weight-based and string distances using particle swarm optimization for prioritizing test cases

Regression testing is concerned with testing the modified version of software. However, to re-test entire test cases require significant cost and time. To reduce the cost and time, higher average percentage fault detection (APFD) rate and faster execution to kill fault mutant are required. Therefore, to achieve these two requirements, an improvement to existing Test Case Prioritization (TCP) technique for a more effective regression testing is offered. A weight-hybrid string distance technique and prioritization using particle swarm optimization (PSO) is proposed. Distance between test cases and weight for each test case, and hybridization of both values for weight-hybrid string distance are calculated. This experiment was evaluated using Siemens dataset. Result obtained from this experiment shows that weight-hybrid string distance is capable of improving APFD values whereby APFD value for hybrid TFIDF-JC is equal to 97.37%, which shows the highest improvement by 4.74% as compared to non-hybrid JC. Meanwhile, for percentage of test cases needed to kill 100% fault mutants, hybrid TFIDF-M yields the lowest value, 22.88%, which shows a 76% improvement as compared to its non-hybrid string distance

A dissimilarity with dice-jaro-winkler test case prioritization approach for model- based testing in software product line

The effectiveness of testing in Model-based Testing (MBT) for Software Product Line (SPL) can be achieved by considering fault detection in test case. The lack of fault consideration caused test case in test suite to be listed randomly. Test Case Prioritization (TCP) is one of regression techniques that is adaptively capable to detect faults as early as possible by reordering test cases based on fault detection rate. However, there is a lack of studies that measured faults in MBT for SPL. This paper proposes a Test Case Prioritization (TCP) approach based on dissimilarity and string based distance called Last Minimal for Local Maximal Distance (LM-LMD) with Dice-Jaro-Winkler Dissimilarity. LM-LMD with Dice-Jaro-Winkler Dissimilarity adopts Local Maximum Distance as the prioritization algorithm and Dice-Jaro-Winkler similarity measure to evaluate distance among test cases. This work is based on the test case generated from statechart in Software Product Line (SPL) domain context. Our results are promising as LM-LMD with Dice-Jaro-Winkler Dissimilarity outperformed the original Local Maximum Distance, Global Maximum Distance and Enhanced All-yes Configuration algorithm in terms of Average Fault Detection Rate (APFD) and average prioritization time

Improving software reliability growth model selection ranking using particle swarm optimization

Reliability of software always related to software failures and a number of software reliability growth models (SRGMs) have been proposed past few decades to predict software reliability. Different characteristics of SRGM leading to the study and practices of SRGM selection for different domains. Appropriate model must be chosen for suitable domain in order to predict the occurrence of the software failures accurately then help to estimate the overall cost of the project and delivery time. In this paper, particle swarm optimization (PSO) method is used to optimize a parameter estimation and distance based approach (DBA) is used to produce SRGM model selection ranking. The study concluded that the use of PSO for optimizing the SRGM’s parameter has provided more accurate reliability prediction and improved model selection rankings. The model selection ranking methodology can facilitate a software developer to concentrate and analyze in making a decision to select suitable SRGM during testing phases. � 2005 - 2017 JATIT & LLS

Comparative evaluation of performance assessment and modeling method for software architecture

Conducting performance assessment during the early phases of system development enhances early design decisions of system design. The generated performance models from system design will help in identifying the potential performance problems in the system design based on the result of the performance assessment. In recent years, several methods for performance assessment and modeling have been proposed. This paper presents the comparative evaluation of performance assessment and modeling methods to discover the strengths and weaknesses of the existing methods based on a set of criteria which includes process and modeling elements that was developed with the purpose to represent a specific process to assess the performance attributes with the help of modeling concepts. The four selected methods were evaluated based on these criterions and the results will hopefully guidance for developers to propose better methods for performance assessment and modeling in the future

A review of real-time software engineering methodologies for developing a wall-climbing robot control firmware

Designing and developing software for autonomous robot control system is a challenging task. Issues related to real-time control, embedded system and artificial intelligence are involved in the software development process. This type of software must be developed with proper software methodology or well-defined development process in order to increase the productivity and quality of the software design and software products. This paper presents a review of two real-time software development methodologies and compares their suitability for developing real-time control software for a wall-climbing robot under development at Universiti Teknologi Malaysia (UTM

A methodology for model-based reliability estimation

In recent years, reliability assessment is an essential process in system quality assessments. However, the best practice of software engineering for reliability analysis is not yet of its matured stage. The existing works are only capable to explicitly apply a small portion of reliability analysis in a standard software development process. In addition, an existing reliability assessment is based on an assumption provided by domain experts. This assumption is often exposed to errors. An effective reliability assessment should be based on reliability requirements that could be quantitatively estimated using metrics. The reliability requirements can be visualized using reliability model. However, existing reliability models are not expressive enough and do not provide consistence-modeling mechanism to allow developers to estimate reliability parameter values. Consequently, the reliability estimation using those parameters is usually oversimplified. With this situation, the inconsistency problem could happen between different estimation stages. In this chapter, a new Model-Based Reliability Estimation (MBRE) methodology is developed. The methodology consists of reliability model and reliability estimation model. The methodology provides a systematic way to estimate system reliability, emphasizing the reliability model for producing reliability parameters which will be used by the reliability estimation model. These models are built upon the timing properties, which is the primary input value for reliability assessment

Combining web engineering methods to cover lifecycle

Web applications have rapidly evolved in the last decade, whilst web engineering methods have been lacking in the process development Web applications. One of the issues in web engineering methods is that no single web engineering method provides adequate coverage for the whole life cycle, because the web engineering methods are divided into three phases, which are; requirements, analysis/design, and implementation. Therefore, each method designed to special concern. It is obvious that we need to design a new method to cover the whole lifecycle to solve this issue. In this paper, we propose a framework for the new web engineering method through a combination of three methods comprising: Navigational Development Techniques (NDT) method for requirements phase; UML-Based Web Engineering (UWE) for analysis/design phase; and Interaction Flow Modeling Language (IFML) for the implementation phase. NDT and UWE are the most representative methods to develop web applications; while IFML is the newest method that focused on design and implementation. Our framework for the new method can support a whole lifecycle. Moreover, this method is more usable from developers