Phases Of Software Development Process Research Articles

Adaptive Security Activities Selection Model Using Multi-Criteria Decision-Making Methods

Adaptive security activities are a list of recommended security activities to be integrated smoothly with the software development life cycle (SDLC) to produce a secure application software. Adaptive security activities are needed due to the emergence of factors and constraints which have been determined as one of the reasons for the underutilisation of security activities implementation, especially in the earlier phase of software development process. Security activities selection models were proposed to select and recommend security activities but the models were focused on certain factors or as a solution for specific constraints, and thus the recommended security activities were not adaptive. Consequently, an adaptive security activities selection (ASAS) model was proposed by combining the factors and constraints faced by the development team in selecting security activities. The model consisted of two integrated multi-criteria decisionmaking (MCDM) methods, namely Analytic Network Process (ANP) and Reference Ideal Method (RIM). ANP was used to prioritise and weight the criteria while RIM was used to measure and evaluate the security activities with the value of constraints in regard to each criterion. To validate the model a case study was performed on four inhouse web application development teams in the Malaysian public sector. The proposed model was able to recommend security activities in the requirement and design phase based on different constraints faced by each of the development teams. The model was adaptive due to its flexibility and ability to change and suit different evolved conditions when recommending the security activities.

Optimization of Interval Type-2 Fuzzy Logic System for Software Reliability Prediction

Since real world application is fraught with high amount of uncertainty, such as applicable to software reliability, there should be a method of handling the uncertainty. This paper presents a model to properly handle uncertainty in software data for effective prediction of the reliability of software at the early phase of software development process. In this paper we employed a Takagi-Sugeno-Kang (TSK)-based interval type 2 fuzzy logic systems with artificial neural network learning for the prediction of software reliability. The degree of membership grades of the interval type 2 fuzzy sets (IT2FSs) are obtained using interval type Gaussian membership function with fixed mean and uncertain standard deviation. The parameters of the IT2FLS membership functions are optimized using gradient descent (GD) back-propagation algorithm. As inputs to the system, reliability relevant software requirement metrics and the software size metrics are used. The proposed new approach makes use of qualitative data of requirement metrics of twenty three real software projects to examine its predictive ability. The performance of the model is evaluated using five performance metrics and found to provide better results when compared with existing approaches.

Optimizing requirement analysis by the use of meta-heuristic in search based software engineering

<p>Requirements analysis is the first phase of software development process and it is one of the main concerns of software engineers. The selection of requirements is a complex problem caused by the heterogeneity of the users and their varied interests and demands. In this paper, it is justified that their is a strong need of optimization in requirement analysis. The paper argues that requirement selection can be viewed as an application area of Search-Based Software Engineering(SBSE). The aim is to justify the claim that requirement engineering can be re-formulated as search problem to which meta-heuristic technique can be applied.</p>

Applying learning-based methods for recognizing design patterns

Recognizing design patterns in source code helps in improving the aspect of reusability and maintainability that play an essential role during analysis and design phases of software development process. Software patterns provide design-level documents, which are applied for the recurring design issues. Analysis of design patterns is often carried out by using forward engineering as well as reverse engineering. In this study, a reverse engineering approach has been applied for recognizing design patterns. The study is comprised of two phases such as preparation of requisite dataset based on object-oriented software metrics and recognition of design patterns. The first phase, i.e., dataset preparation, is carried out by various object-oriented metrics. Design pattern recognition is performed by using learning-based algorithms such as artificial neural network and logistic regression. The presented method is validated by using three case studies such as JRefactory, JUnit and Quaqua.

Supporting Expertise Location in Coding Phase of Software Development Process

Software organizations attempt to reduce the time and cost of software projects to maintain competition between organizations, one way to achieve this goal is by applying knowledge gained from previous projects or resources used by members of the organization. However, software developer teams generally do not benefit from this knowledge as it is rarely stored. This is a problem since to solve problems or doubts developers need to seek expertise (knowledge of the best level at the right time) to maintain the level of competition and the fact of not having information of this knowledge makes it difficult to identify and in some cases, this is lost when the provider leaves the company. This work addresses the expertise location problem through an agent-based architecture for coding phase of software development process, which was designed from the information obtained by a focal group and with a case study of the search for expertise in software development organizations.

Comparative evaluation of genetic algorithm-based test case optimization

Software testing is a crucial phase in software development process although it consumes more time and cost of software development. Researchers have proposed several approaches focusing on helping software testers to reduce the execution time and cost of the testing process. Test case optimization is a multi-objective approach that has become one of the best solutions to overcome these problems. Test case optimization focusing on reducing the number of test cases in the test suite that may reduce the overall testing time, cost and effort of software testers especially in regression testing. This paper presents the comparative evaluation between test case optimization techniques that are based on Genetic Algorithm (GA). The evaluation is based on five criteria i.e. technique objectives, applied fitness function, contributions, the percentage of the reduced test cases, fault detection capability, and technique limitations. The evaluation results able identify the gaps in the existing GA-based test case optimization approaches and provide insight in determining the potential research directions in this area.

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.

Automated Test Case Generation from UML Activity Diagram and Sequence Diagram using Depth First Search Algorithm

Software testing is an important and critical activity in software development that deals with software quality. However, the testing process is consuming activities that need to be automated to save a lot of resources. Towards automated testing, automating test cases generation as the first testing process is being highlighted. This research aims to generate test case automatically from UML diagram since model based testing that conducted on early phase of software development process show higher efficiency. UML diagrams used in this research are activity diagram, sequence diagram and SYTG as the combination graph. These three diagrams have been proved as the most compatible diagram to generate test case from previous research. Method proposed in this paper is Depth First Search algorithm that is modified to generate expected test cases. This paper proves that modified DFS algorithm applied to generate test case is provide accurate result, every node presented on the test case, include any condition (alt and opt). Comparison result from three different test cases generated shows that test cases from combined UML may not necessarily result in better test cases, due to the possibility of redundant test cases for some test cases. This paper also presenting an experiment result that proving sequence diagrams can produce better test cases.

Fine-Granular Model Merge Solution For Model-Based Version Control System

Software Configuration Management (SCM) aims to provide a controlling mechanism for the evolution of software artifacts created during software development process. Controlling software artifacts evolution requires many activities to be carried out such as, construction and creation of versions, computation of mappings and differences between versions, merging (i.e. combining of two or more versions) and so on. Traditional SCM systems are file-based SCM systems, which are not adequate for performing software configuration management activities. File-based SCM systems consider software artifacts as a set of text files, while today’s software development is model-driven and models are the main artifacts produced in the early phases of software development process. New challenges of model mappings, differencing, merging, and conflict detection arise when applying file-based solution to model-driven software. The goal of this paper is to develop a configuration management solution for model merging and conflict resolution that overcomes the challenges faced by traditional SCM systems for model-based development. We represent models at finegrained level as graph structures, which is an intermediate representation based on graph theory. Our approach follows a 3-way model merge process, where a base and its derived versions are used for comparison. To differentiate between conflicted and non-conflicted cases, we have defined different merge cases, and established a merge policy based on merge cases. Merge cases are used along with the comparison result in order to perform conflict resolution and merge operation. We performed a controlled experiment using open source eclipse modeling framework and compare our approach with an open source tool Eclipse Modeling Framework (EMF) Compare. The results proved the accuracy and efficiency of our proposed approach.

Model to Quantify Integrity at Requirement Phase

Objectives: The software security and its proper measurement involve various tools and techniques. To make software secure its foundation stone, the requirement, should also be secure and therefore the integrity control for requirement at the same phase became the objective for delivering secure requirement and so forth the software. Method/Analysis: The past research study entails about less secure software deliver by industries and among the major cause of security lacking, one cause is integrity to requirements. Requirement integrity can be observed as trustworthy, complete and veracity requirement for producing secure software. Only conceptual notion of integrity is not capable to make any component secure but it must be depicted in understandable and quantifiable idiom for assessing the better security solution to requirement and therefore to software. Findings: MQIR (Model to quantify integrity) for requirement at requirement phase of software development process is a new assessment technique that tries to satisfy all major constraints regarding secure requirements and so forth for software. To implement this new technique a relevant set of values in terms of input is captured for proper data management from various live projects under going in some software companies of repute. An appropriate quantification of requirement data is also furnished for sufficient checking of security level and its efficiency. The technique has also been validated through capturing online shopping data so that its implications may also be assessed accurately. Novelty/Improvement: As far as the application of this technique (MQIR) is concern, the article emphasis on complete usability of online functioning at its highest level of integrity that maintains security with the boundary conditions of e-commerce.

REQUIREMENT VALIDATION VS. REQUIREMENT ELICITATION

To support the evocation and validation of the goals achieved by the existing system and to illustrate problems of the old system, we suggest to capture current system usage using rich media (e.g., video, speech, pictures, etc.) and to interrelate those observations with the goal definitions .Therefore it becomes necessary to relate the parts of the observations which have caused the definition of a goal or against which a goal was validated with the corresponding goal in every phase of software development process. These interrelations provide the base for: 1) explaining and illustrating a goal model to, e.g., untrained stakeholders and/or new team members, and thereby improving a common understanding of the goal model; 2) detecting, analyzing, and resolving a different interpretation of the observations; 3) comparing different observations using computed goal annotations; and 4) refining or detailing a goal model during later process phase. Using the PRIME implementation framework, we have implemented the PRIME-CREWS environment, which supports the interrelation of conceptual models and captured system usage observations. We report on our experiences with PRIME-CREWS gained in a first experimental case study. The successful implementation of proposed requirement evocation and validation process can have a good impact on the production of quality software product.

Reusability Estimation Model for Object Oriented Software

2 Abstract: Estimating Reusability near the beginning in the software development life cycle, particularly at design phase, may help the designers to integrate required improvement and corrections for improving overall quality of the developed software. This research paper proposes a framework for reusability estimation that provides step by step solution for reusability estimation of object oriented software. As well as study developed a multivariate regression model ‗Reusability Estimation Model for Object-Oriented software' at design phase of software development process. Proposed model has been mathematically validated through proper statistical measures and contextual explanation has been drawn. This study facilitates the software developers, designer and quality controllers, the inclusion of reusability estimation model to access and quantify software reusability for quality product. Reusability estimation in early stage of software development life cycle always supports the designers to improve the reusability of product class diagram and consequently the reusability of software.

A Versatile Approach for the Estimation of Software Development Effort Based on SRS Document

Requirement engineering is a disciplined application of proven principles, methods, tools and notations to describe the behavior of a system. Generally a project suffers because of improper determination and documentation of software requirements. The intricacies in software development processes are often not understood by the client. Hence, requirements submitted by client need a careful examination. In order to produce proper artifact, it is necessary that the software requirements should be documented into the software requirement specification (SRS) on the basis of the recommendations of IEEE 830:1998 document. To address these issues, a measure for early estimation of software complexity based on SRS of the yet to be developed software is proposed. Further, this complexity measure serves as a basis for computing and deriving early estimation of software development effort too. The results obtained from the proposed measure are able to establish that the measure is accurate and precise as compared to various other existing measures that are based on the algorithm/parameters, software code, function point analysis and use case points. All this is accomplished using SRS document at an early phase of software development process. The proposed measure is robust, comprehensive, early alarming and compares well with other development effort estimation measures proposed in the past.

Security considerations for the spiral development model

Security measures have been well established within the waterfall development life cycle model. However, more software projects are using the spiral development life cycle model. Software developers and project managers can easily forget about adapting security measures. The spiral model uses iterative steps that can create changes in each phase of software development process. This will challenge security to ensure the application has few flaws or vulnerabilities that could be exploited. Failure to impose the right security measures at each of these phases can open up vulnerabilities for hackers to exploit and prove costly in patching. This paper will explore areas where security can be engaged within each iteration step of the spiral development model. This way security can continue protection of the software product as it becomes ready for deployment. The paper will help organizations realize where to deploy security measures to reduce vulnerabilities in the software application.

ESUML-EAF: a framework to develop an energy-efficient design model for embedded software

There is a growing interest in developing embedded systems that consume low energy in such application areas as mobile communications or wireless sensor networks. To especially provide the complex and diverse functions of embedded software with limited energy consumption, many studies of low-energy software are being performed. The existing studies to analyze energy consumption of embedded software have mainly focused on source code. However, some studies recently explored model-based energy consumption analysis to fulfill the requirement of energy consumption in the early phase of software development process. This paper proposes a model-based energy consumption analysis framework to develop an energy-efficient design model of embedded software. The proposed framework can analyze energy consumption without building an additional analysis model in software development and provide the chance to fulfill the energy consumption requirements in the early phase of the software development process, which can reduce the feedback efforts.

Software Testing-Three P'S Paradigm and Limitations

Software Testing is an important area of research in the field of software engineering because it is the deciding factor for successful project release and directly proportion to software quality and reliability. A lot of research has been already done in this field, likely to be leveraged in future as software has become integral part of each and every domain to make it faster, easier and smarter. Software testing is regarded as the most important phase of software development process, as without testing it is impossible to diagnose errors. This paper explains the phases, principles and limitations of software testing. We tried to accumulate principles after detailed analysis of phases of testing, based on available methodologies, users involved & importance of software testing. All the terms which are considered as building blocks of software testing are discussed in this paper to enhance the overall quality of a system and to ensure successful project release. General Terms

A FRAMEWORK FOR INTEGRATING FORMAL SPECIFICATION, REVIEW, AND TESTING TO ENHANCE SOFTWARE RELIABILITY

Software risk comes mainly from its poor reliability, but how to effectively achieve high reliability still remains a challenge. This paper puts forward a framework for systematically integrating formal specification, review, and testing, and shows how it can be applied to effectively eliminate errors in the major phases of software development process to enhance software reliability. In this framework, requirements errors can be removed and missing requirements can be identified by formalizing requirements into formal specifications whose validity can be ensured by rigorous review. The valid specification can then be used as a firm foundation for implementation and for rigorous inspection, testing, and walkthrough of the implemented program. We discuss how formalization, review, and testing work together at different levels of software development to improve software reliability through detecting and removing errors in documentation.

Identification of aspect candidates by inspecting use cases descriptions

The identification of aspect candidates in the early phases of software development process allows improving the modularization of the requirements, to detect conflicts early and maintain the separation of concerns in the later phases of the process. However, the identification of aspects in initial phases is a non-trivial task, which can be costly and too time-consuming. This paper presents a technique to assist in the identification of aspect candidates in the requirements, through inspection. Two case studies were carried out to evaluate the proposed technique. The results obtained from the case studies let us conclude that the proposed technique facilitates the identification of aspect candidates.

Software Architecture and Methodology as a Tool for Efficient Software Engineering Process: A Critical Appraisal

The foundation for any software system is its architecture. Software architecture is a view of the system that includes the system’s major components, the behaviour of those components as visible to the rest of the system, and the ways in which the components interact and coordinate to achieve the overall system’s goal. Every efficient software system arises as a result of sound architectural basement. This requires the use of good architecture engineering practices and methods. This paper recognizes software architecture practice as a discipline pervading all phases of software development and also presents an enhanced model for software engineering process which provides an avenue for speedy, efficient and timely delivery of software products to their intended users. The integration of software architecture into the phases of software development process in a generic software life cycle is also contained in this research report. This is to enable software engineers and system analysts to use effective software architecture practices and to employ appropriate methodology during the software engineering process.

DATA MINING FOR THE MANAGEMENT OF SOFTWARE DEVELOPMENT PROCESS

In this paper we present a new method for the application of data mining tools on the management phase of software development process. Specifically, we describe two tools, the first one based on supervised learning, and the second one on unsupervised learning. The goal of this method is to induce a set of management rules that make easy the development process to the managers. Depending on how and to what is this method applied, it will permit an a priori analysis, a monitoring of the project or a post-mortem analysis.