Phases Of Software Life Cycle Research Articles

Program source code comprehension by module clustering using combination of discretized gray wolf and genetic algorithms

Maintenance is a critical and costly phase of software lifecycle. Understanding the structure of software will make it much easier to maintain the software. Clustering the modules of software is regarded as a useful reverse engineering technique for constructing software structural models from source code. Minimizing the connections between produced clusters, maximizing the internal connections within the clusters, and maximizing the clustering quality are the most important objectives in software module clustering. Finding the optimal software clustering model is regarded as an NP-complete problem. The low success rate, limited stability, and poor modularization quality are the main drawbacks of the previous methods. In this paper, a combination of gray wolf optimization algorithm and genetic algorithms is suggested for efficient clustering of software modules. An extensive series of experiments on 14 standard benchmarks have been conducted to evaluated the proposed method. The results illustrate that using the combination of gray wolf and genetic algorithms to the software-module clustering problem increases the quality of clustering. In terms of modularization quality and convergence speed, proposed hybrid method outperforms the other heuristic approaches.

The Cloze Procedure as a Measure of Program Understanding.(Dept.E)

The process of program understanding plays an important role in testing, and maintenance phases of software life cycle. There have been numerous investigations of the influence of various aspects of a program on program understanding, using many different measures of understanding. Some of the different measures include time to find a bug, a comprehension quiz, ability to reporduce a functionally equivalent program without notes, time to perform modification. All of these measures have some limitations. A new measure called CLOZE procedure, which has less limitations as well as other advantages such as ease of administration and grading, is investigated in this paper . The paper reports on a controlled experiment that compared CLOZE procedure and the time to find a bug as measuring program understanding. The experiment results indicated that the CLOZE procedure measure is a fair measure for program understanding. It may best be used in educational environments where computerizing test construction, as well as grading, is highly appreciated.

Empirical Investigation of Influencing Factors Regarding Offshore Outsourcing Decision of Application Maintenance

Global Software Development (GSD) has been an emerging trend in the development of software globally, for the last two decades. Information Technology (IT) outsourcing includes application development, application maintenance, infrastructure management and business process outsourcing. Software maintenance aims to keep the IT system operational and to fulfill the client requirements. The maintenance is considered the longest phase of software life cycle that consumes about 60-70% of the total software budget. Maintenance of software is not only time consuming but also requires a significant human resources’ ratio. Mostly, software acquisition and maintenance consume a big portion of the total IT budget. The current study aims to evaluate the findings of the systematic literature review and to derive a list of critical success factors regarding offshore outsourcing decision of application maintenance. Thus, an empirical study is performed to validate the influencing factors that were identified by using systematic literature review. These factors are further validated by 93 outsourcing experts from 30 different countries. The collected data through online survey is analyzed based on variables such as respondents experience level, respondents’ locations (continents), experts’ positions. Similarly, the data is analysed based on Chi square test (linear by linear association) and Spearman Rank Correlation. Additionally, the identified factors through survey and systematic literature review are ranked by two different methods. Consequently, a project assessment model is proposed, based on the critical success factors for the sourcing decision of application maintenance.

A Fuzzy Logic-Based Model for Classifying Software Modules in Order to Achieve Dependable Software

In this study, a fuzzy logic-based framework has been proposed to predict the situation of the software modules in the earlier phases of software lifecycle. The proposed model has taken into account domain experts' opinions and the available state of different software metrics as inputs. On the basis of dependability measures of software, different modules have been ranked earlier in the development process. Effect of the modules on the reliability, security, and availability of software has been judged by the proposed technique based on Mahalanobis distance metric. The study of software dependability in early phase assists the software developers to take corrective actions, which leads to minimize the testing efforts as well as development time. The proposed technique has been implemented on the promise software engineering repository data set. Performance of the proposed methodology is promising in identifying the fault-prone software modules. The result has also been compared with some known methodologies.

A novel change impact model for enhancing project management

Software systems changes constantly with time. Changing the software affects all the classes associated with it. For effective project management it becomes important to predict change impact classes in earlier phases of software life cycle. This paper aims to develop a novel model using dynamic metrics and several behavioural dependencies. Using code analyser trace events 30 different metrics are analysed which are further used for refining the degree of change impact feature of a class. Further the model is validated using K-means clustering technique, naïve Bayes classification and logistic regression in WEKA tool. Validation of the model is done using open source software Art of Illusion (AoI).

A Novel technique for test case minimization in object oriented testing

Software maintenance is the costliest phase of software life cycle and it consumes almost 70 percent of resources of development process. Software testing involves the examining the built software with the intension to find the defects in it. Exhaustive testing of the software for all possible test cases is not feasible as may take infinitely large amount of time and may consume large number of other resources. Researchers in the field of the software testing are exploring the different possibilities to reduce the required number of test cases to test given software. In case of an object oriented (OO) software, the complexities like inheritance, coupling and cohesion, make the software modules more prone to the faults. This problem gets augmented in case of very large software systems. Many researchers have solved the problem of test case minimization from the different perspectives like requirements coverage; statement coverage and risk coverage. But negligible research has been done of the basis of security metrics coverage. In this paper, a technique has been presented for minimization of test cases for the OO systems. The research reported in the paper has considered security as a perspective for test cases evaluation and minimization. Publically available data sets pertaining to open source software Camel 1.6.1 have been used for the evaluation of proposed methodology. Linear Regression (LR) model for the bugs present in the data and various object oriented metrics for security have been developed. The proposed model dissects the given metrics sets into effective and non-effective metrics. Effective metrics are then utilized for giving weights to the test cases, further with the help of weights obtained the test suite is minimized. The performance results of proposed approach are encouraging.

A novel change impact model for enhancing project management

Software systems changes constantly with time. Changing the software affects all the classes associated with it. For effective project management it becomes important to predict change impact classes in earlier phases of software life cycle. This paper aims to develop a novel model using dynamic metrics and several behavioural dependencies. Using code analyser trace events 30 different metrics are analysed which are further used for refining the degree of change impact feature of a class. Further the model is validated using K-means clustering technique, naive Bayes classification and logistic regression in WEKA tool. Validation of the model is done using open source software Art of Illusion (AoI).

Development of an approach to using a style in software engineering

An ontology-driven approach to applying styles in software engineering is developed in the study. The essence of the approach is to use ontology not only to represent styles but also to control the use of styles when creating and maintaining software. For such purposes, appropriate ontology and developer support tools are provided to represent a style, and tools (reasoners) are created on the ground of the ontological knowledge base to control the application of the style in work products of the software lifecycle phases. Based on descriptive logic, the knowledge base contains two components – terminological (TBox) and factual (ABox). The first component was created in advance by performing a domain analysis. The second component was created when analysing the representation of the corresponding work product. For the purpose of typification in the context of the developed approach, templates for the kernel ontology of the software engineering style were created by analysing the concept of style in different domains. The basic characteristics of style as a domain-independent concept, which are presented in the templates, are formulated in the article. In this case, the Work Product Pattern Application pattern of the Unified Foundational Ontology is used to select the number of templates needed to represent the style. The pattern describes actions that may exist regarding the Work Product style. An example of using the approach is considered by investigating the proposed ontology-driven method for programming style application in software engineering and building the architecture of the tool that implements it. Protege use shows how to build the ontology of a programming style and programmer support. The architecture of the tool for controlling the application of style is developed and implemented in a work product of the design phase – a programme text. The basis of the architecture is the knowledge base of the corresponding style. The terminological component of the knowledge base contains information regarding programming languages and styles, and it is created in advance by the ontology developer. The actual component is created by the reasoner for each representation of the work product – the programme text. The tools developed in the context of the proposed approach automate the processes that take place when applying styles to work products of the software lifecycle phases.

A fuzzy rule-based generation algorithm in interval type-2 fuzzy logic system for fault prediction in the early phase of software development

ABSTRACTReliability, a measure of software, deals in total number of faults count up to a certain period of time. The present study aims at estimating the total number of software faults during the early phase of software life cycle. Such estimation helps in producing more reliable software as there may be a scope to take necessary corrective actions for improving the reliability within optimum time and cost by the software developers. The proposed interval type-2 fuzzy logic-based model considers reliability-relevant software metric and earlier project data as model inputs. Type-2 fuzzy sets have been used to reduce uncertainties in the vague linguistic values of the software metrics. A rule formation algorithm has been developed to overcome inconsistency in the consequent parts of large number of rules. Twenty-six software project data help to validate the model, and a comparison has been provided to analyse the proposed model’s performance.

Software change‐proneness prediction through combination of bagging and resampling methods

AbstractIdentifying the change‐prone parts of software could help managers and developers to effectively allocate maintenance resource and time during early phases of software life cycle. Change‐proneness prediction on file level with binary classification methods makes such identification possible. As the fact that change‐prone files frequently account for a small part of all the files, the prediction performance of standard classification methods is not satisfying. In this paper, we employ imbalanced learning methods, including bagging, resampling, and especially their combination to reduce the performance decrease of standard classifiers caused by the class imbalance problem in change‐proneness prediction. Besides, we propose a boxplot‐based partition method to provide more proper change‐proneness label designation for the training data. Eight open‐source Java projects are chosen in the empirical study to validate the effectiveness of the combination methods in change‐proneness prediction. The experimental results of the empirical study show that combining bagging with resampling can significantly improve the prediction performance of only bagging or resampling. Of all the combination methods employed, combination of bagging with undersampling performs better than others. And support vector machine is more effective as a base classifier than J48 and naive Bayes.

A Review on Software Project Management Ontologies

This article aims to provide the reader with a comprehensive background for understanding current knowledge and research works on ontologies for software project management (SPM). It constitutes a systematic literature review behind key objectives of the potential adoption of ontologies in PM. Ontology development and engineering could facilitate substantially the software development process and improve knowledge management, software and artifacts reusability, internal consistency within project management processes of various phases of software life cycle. The authors examined the literature focusing on software project management ontologies and analyzed the findings of these published papers and categorized them accordingly. They used qualitative methods to evaluate and interpret findings of the collected studies. The literature review, among others, has highlighted lack of standardization in terminology and concepts, lack of systematic domain modeling and use of ontologies mainly in prototype ontology systems that address rather limited aspects of software project management processes.

A Mahalanobis distance based algorithm for assigning rank to the predicted fault prone software modules

This article proposes a methodology based on Artificial Neural Network(ANN) and type-2 fuzzy logic system (FLS) for detecting the fault prone software modules at early development phase. The present research concentrates on software metrics from requirement analysis and design phase of software life cycle. A new approach has been developed to sort out degree of fault proneness (DFP) of the software modules through type-2 FLS. ANN is used to prepare the rule base for inference engine. Furthermore, the proposed model has induced an order relation among the fault prone modules (FPMs) with the help of Mahalanobis distance (MD) metric. During software development process, a project manager needs to recognize the fault prone software modules with their DFP. Hence, the present study is of great importance to the project personnel to develop more cost-effective and reliable software. KC2 dataset of NASA has been applied for validating the model. Performance analysis clearly indicates the better prediction capability of the proposed model compared to some existing similar models.

A Systematic Literature Review on the Application of Ontologies in Automatic Programming

One of the main goals of the Software Engineering discipline is to find higher abstraction levels and ways to reuse software in order to increase its productivity and quality. Ontologies, which are typically considered as a technique or an artifact used in one or more software lifecycle phases, may be used to help achieve that goal. This paper provides a systematic literature review of the proposed solutions for applying ontologies in automatic and generative programming. The paper aims to identify ontologies and software development tools, frameworks, prototypes, design patterns and methodologies that use them as development artifacts for source code generation or product derivation. The review provides researchers with the state of the art, while also identifying challenges and gaps that require further exploration and development.

A bayesian belief network based model for predicting software faults in early phase of software development process

It is always better to have an idea about the future situation of a present work. Prediction of software faults in the early phase of software development life cycle can facilitate to the software personnel to achieve their desired software product. Early prediction is of great importance for optimizing the development cost of a software project. The present study proposes a methodology based on Bayesian belief network, developed to predict total number of faults and to reach a target value of total number of faults during early development phase of software lifecycle. The model has been carried out using the information from similar or earlier version software projects, domain expert’s opinion and the software metrics. Interval type-2 fuzzy logic has been applied for obtaining the conditional probability values in the node probability tables of the belief network. The output pattern corresponding to the total number of faults has been identified by artificial neural network using the input pattern from similar or earlier project data. The proposed Bayesian framework facilitates software personnel to gain the required information about software metrics at early phase for achieving targeted number of software faults. The proposed model has been applied on twenty six software project data. Results have been validated by different statistical comparison criterion. The performance of the proposed approach has been compared with some existing early fault prediction models.

The Research Framework for Quantitative Safety Assessment for Safety-Critical Computer Systems

Objectives: A safety-critical computer system has to be designed with safety in mind. The purpose of this paper is to identify and assess the safety hazards by using the proposed framework for Safety-Critical Computer Systems (SCCS). Methods/Statistical Analysis: Computer software quality models like McCall’s and Boehm’s were deficient in addressing the basic safety issues of SCCS. This paper proposes another safety model for software safety by adjusting McCall’s product quality model that particularly distinguishes the conditions comparing to software safety in safety-critical applications. The conditions in the proposed software safety model relate to Hazard Analysis distinguishing of Completeness of safety requirements, Safety-critical Design, Coding, and Testing. Findings: The criteria in the proposed software safety model relate to Hazard Analysis (HA) distinguishing of safety requirements, Completeness of safety requirements, Safety-critical Design, Safety-critical Coding, and Safety-critical Testing. The proposed safety model changes the current quality model by presenting different safety criteria’s and metrics in all phases of Software life cycle to assess the software safety. This model was connected to a safety basic Railroad Crossing Control System (RCCS) which is a laboratory prototype and obtained better results in terms of safety. Application/Improvements: This model was connected to a safety basic Railroad Crossing Control System (RCCS) which is a laboratory prototype and obtained better results in terms of safety.

Automatic Generation of Basis Component Path Coverage for Software Architecture Testing

Architecture-centric development is one of the most promising methods for improving software quality, reducing software cost and raising software productivity. Software architecture research not only focuses on the design phase, but also covers every phase of software life cycle. Software architecture has characteristics different from traditional software, conventional testing methods do not apply directly to software architecture. Basis path testing is a very simple and efficient white-box testing method. Traditional methods generate basis path according to the control flow graph, they are not suitable for generating component path when we detect more software architecture errors. This paper presents a new concept - Basis Component Path (BCP) for C2-style architecture, and proposes a method to generate the BCPs. C2-style architecture is represented by components, connectors, and interfaces, and uses an architecture component interaction graph (CIG) to describe interface connection relationship. We also provide an algorithm to generate BCP set. Experiments apply the proposed method in a typical C2-style architecture and the result shows that the proposed method can generate BCP set which contains as many BCPs as possible efficiently, and it meets the requirements of the basis component path testing.

An Overview on the use of Ontologies in Software Engineering

One of the main goals of the Software Engineering (SE) discipline is to find higher abstraction levels and ways to reuse software in order to increase its productivity and quality. Ontologies, which are typically considered as a technique or an artifact used in one or more software lifecycle phases, may be used to help achieve that goal. This paper provides a literature review, discussion and analysis of the existing solutions for implementing ontologies in SE. We selected several software development paradigms (including Software Product Lines, Component-Based Development, Generative Programming and Model-Driven Engineering) for our classification and discussion of different approaches proposed in the literature. It was established that ontologies are suitable for providing a common vocabulary to avoid misunderstanding between different parties in SE, requirements specification, features specification, variability management, components specification, components matching, model transformations and code generation. Based on the conducted review, guidelines for further research are given.

Software Reliability Analysis of NASA Space Flight Software: A Practical Experience.

In this paper, we present the software reliability analysis of the flight software of a recently launched space mission. For our analysis, we use the defect reports collected during the flight software development. We find that this software was developed in multiple releases, each release spanning across all software life-cycle phases. We also find that the software releases were developed and tested for four different hardware platforms, spanning from off-the-shelf or emulation hardware to actual flight hardware. For releases that exhibit reliability growth or decay, we fit Software Reliability Growth Models (SRGM); otherwise we fit a distribution function. We find that most releases exhibit reliability growth, with Log-Logistic (NHPP) and S-Shaped (NHPP) as the best-fit SRGMs. For the releases that experience reliability decay, we investigate the causes for the same. We find that such releases were the first software releases to be tested on a new hardware platform, and hence they encountered major hardware integration issues. Also such releases seem to have been developed under time pressure in order to start testing on the new hardware platform sooner. Such releases exhibit poor reliability growth, and hence exhibit high predicted failure rate. Other problems include hardware specification changes and delivery delays from vendors. Thus, our analysis provides critical insights and inputs to the management to improve the software development process. As NASA has moved towards a product line engineering for its flight software development, software for future space missions will be developed in a similar manner and hence the analysis results for this mission can be considered as a baseline for future flight software missions.

Ontologies for Software Engineering: Past, Present and Future

Background/Objectives: Research in recent years has probed integration amongst research field of Software Engineering & Semantic Web technology, addressing the advantages of applying Semantic techniques to the field of Software Engineering. Prolifically published studies have further substantiated the benefits of ontologies to the field of Software Engineering, which clearly motivate us to explore further opportunities available in this collaborated field. This paper is a survey expounding such opportunities while discussing the role of ontologies as a Software Life-Cycle support technology. Method/Statistical Analysis: Survey centred on providing an overview of the state-of-art of all the ontologies available for Software Engineering followed by their categorization based on software life cycle phases and their application scope. Findings: Characterization of ontologies as a Software Life-cycle support technology, instigated by the increasing need to investigate the interplay between Semantic Web & Software Engineering with the ultimate goal of enabling & improving Software Engineering capabilities. Application/Improvements: This paper discusses the practical and potential applications of ontologies in the field of Software Engineering followed by the issues and challenges that will keep this field dynamic and lively for years to come.

A Survey of Bayesian Network Models for Decision Making System in Software Engineering

Defect prediction and assessment are the essential steps in large organizations and industries where the software complexity is growing exponentially. A large number of software metrics are discovered and used for metric prediction in the literature. Bayesian networks are applied to find the probabilistic relationships among the software metrics in different phases of software life cycle. Defects in a software project lead to minimize the quality which might be the impact on the overall defect correction. Traditional Bayesian networks are system dependable and their models are invariant towards the accurate computation. Bayesian network model is used to predict the defect correction at various levels of the software development. This model reveals the high potential software efforts and metrics required to minimize the overall cost of the organization for decision support.