Phases Of Software Life Cycle Research Articles

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.

Predicting Software Product Quality: A Systematic Mapping Study

Predicting software product quality (SPQ)is becoming a permanent concern during software lifecycle phases. In this paper, a systematic mapping studywas performed to summarize the existing SPQ prediction(SPQP) approaches in literature and to organizethe selected studies according to seven classificationcriteria: SPQP approaches, research types, empiricaltypes, data sets used in the empirical evaluation of thesestudies, artifacts, SQ models, and SQ characteristics.Publication channels and trends were also identified.After identifying 182 documents in ACM Digital Library,IEEE Xplore, ScienceDirect, SpringerLink, and Googlescholar, 69 papers were selected. The results showthat the main publication source of the papers identifiedwas conference. Data mining techniques are themost frequently SPQP approaches reported in literature.Solution proposal was the main research type identified.The majority of the papers selected were history-basedevaluations using existing data which were mainly obtainedfrom open source software projects and domainspecific projects. Source code was the main artifactconcerned with SPQP approaches. Well-known SQmodels were hardly mentioned and reliability is the SQcharacteristic through which SPQP was mainly achieved.SPQP-related subject seems to need more investigationfrom researchers and practitioners. Moreover, SQ modelsand standards need to be considered more in futureSPQP research.

Interdisciplinary design of scheduling decision support systems in small-sized SME environments: The i-DESME framework

This paper introduces i-nterdisciplinary DEsign for SMEs (i-DESME), a structured interdisciplinary framework for the design of IT scheduling decision support systems, with a focus on small-sized Small and Medium Enterprises (SME) industrial environments. The proposed framework initially models the interdisciplinary characteristics of the current (‘as-is’) implementation of scheduling processes within a particular SME industrial environment. This information provides the basis for the implementation of function allocation and algorithm selection studies on the scheduling processes considered. As a result, an interdisciplinary specification of the information technology (IT) decision support system which will support the future (‘to-be’) implementation of the scheduling processes within the industrial environment is produced, and subsequent software lifecycle phases are implemented. A summary of case study results from the application of the i-DESME framework within the environment of a typical micro-sized SME company is provided.

The applications of SFTA and SFMEA approaches during software development process: an analytical review

Software fault tree analysis SFTA and software failure modes and effects analysis SFMEA are two well known recommended approaches for the analysis of software induced hazards in the system and are adapted in the software domain by employing the concepts of standard hardware safety approaches namely fault tree analysis FTA and failure modes and effects analysis FMEA respectively. Both SFTA and SFMEA approaches, since their inception in the software domain, have been explored, either individually or jointly, by researchers at different stages of software development. This paper presents the critical review of the published work about the applications of both these approaches in three phases, namely requirements analysis, design and implementation/coding phases of software life cycle. After presenting the analytical review, the paper identifies the problems that are currently faced during the applications of these approaches and guides the directions for carrying out further research.

Personality Profiles of Software Engineers and Their Software Quality Preferences

Studies related to human aspects in software engineering (SE) have been performed from different perspectives. These perspectives include the study of human factors in different phases of software life cycle, effect of team performance in software development, how can a personality trait suit a particular task, and about some other miscellaneous issues. This research work aims to establish personality profiles of Pakistani software engineers using the Myers-Briggs Type Indicator (MBTI) instrument. This survey has collected personality profiles of 110 software engineers. Moreover, their preferences of software quality attributes have also been collected. Analysis of the study shows that the most prominent personality type is a combination of introversion, sensing, thinking and judging. Investigative results indicate that most of the software engineers consider usability and functionality as the most important software quality attributes.

ABC: 一种全生命周期软件体系结构建模方法

With the continually-increasing capability of computer hardware and scale of computer software, the complexity of software is also continually increasing, and has manifest itself as one of the key factors that limit the significant improvement of software quality and productivity. The structural complexity, especially the high-level structural complexity, is considered as the most important complexity of a software system. How to control the high-level structural complexity in efficient and effective ways has become a critical issue for large-scale software development in the Internet computing environment, which is open, dynamic and constantly changing. To resolve this problem, this article extends the software architecture (SA) models-a kind of model aiming to control the high-level structural complexity on software designing-into the whole software lifecycle, and proposes an SA centric software development method, called ABC. The ABC method unifies the core artifacts in different software lifecycle phases into different kinds of SA models, and then the core activities of software development, deployment, maintenance and evolution are performed as the continual refinement, mapping, and transformation to these different kinds of SA models. In particular, this article aims to give a systematic introduction to the ABC method, and present some latest research outputs in collaborative feature modeling, runtime SA generation, and SA recovering.

Application of Group Method of Data Handling model for software maintainability prediction using object oriented systems

Object-oriented methodology has emerged as most prominent in software industry for application development. Maintenance phase begins once the product is delivered and by software maintainability we mean the ease with which existing software could be modified during maintenance phase. We can improve and control software maintainability if we can predict it in the early phases of software life cycle using design metrics. Predicting the maintainability of any software has become critical with the increasing importance of software maintenance. Many authors have practiced and proved theoretical validation followed by empirical evaluation using statistical and experimental techniques for evaluating the relevance of any given metrics suite using many models. In this paper, we have presented an empirical study to evaluate the effectiveness of novel technique called Group Method of Data Handling (GMDH) for the prediction of maintainability over other models. Although many metrics have been proposed in the literature, software design metrics suite proposed by Chidamber et al. and revised by Li et al. have been selected for this study. Two web-based customized softwares developed using C# Language have been used for empirical study. Source code of old and new versions for both applications were collected and analysed against modifications made in every class. The changes were counted in terms of number of lines added, deleted or modified in the classes belonging to new version with respect to the classes of old version. Finally values of metrics were combined with “change” in order to generate data points. Hence, in this study an attempt has been made to evaluate and examine the effectiveness of prediction models for the purpose of software maintainability using real life web based projects. Three models using Feed Forward 3-Layer Back Propagation Network (FF3LBPN), General Regression Neural Network (GRNN) and GMDH are developed and performance of GMDH is compared against two others i.e. FF3LBPN and GRNN. With the aid of this empirical analysis, we can safely suggest that software professionals can use OO metric suite to predict the maintainability of software using GMDH technique with least error and best precision in an object oriented paradigm.

Ontologies for Software Project Management: A Review

Software Project Management is a knowledge intensive process that can benefit substantially from ontology development and ontology engineering. Ontology development could facilitate or improve substantially the software development process through the improvement of knowledge management, the increase of software and artefacts reusability, and the establishment of internal consistency within project management processes of various phases of software life cycle. A large number of ontologies have been developed attempting to address various software engineering aspects, such as requirements engineering, components reuse, domain modelling, etc. In this paper, we present a systematic literature review focusing on software project management ontologies. The literature review, among other, has identified lack of standardization in terminology and concepts, lack of systematic domain modelling and use of ontologies mainly in prototype ontology systems that address rather limited aspects of software project management processes.

Using Aspects for Platform-Independent to Platform-Dependent Model Transformations

This paper presents an aspect-based approach for realizing a transformation from platform-independent to platform-dependent models in the context of a model transformation chain that generates queueing-based performance models from UML design models of serviceoriented applications. The purpose of generating such performance models is to evaluate the performance of the system under development in the early software lifecycle phases, in order to insure that it will meet the performance requirements. The paper presents the model transformation chain PUMA4SOA, which transforms automatically a UML model of a service-oriented architecture (SOA) system extended with MARTE performance annotations into an intermediate model, Core Scenario Model (CSM), which in turn is used to generate a Layered Queueing Network (LQN) performance model. Aspect-oriented modeling is used to represent different services offered by the underlying SOA platform to the SOA application. The paper discusses and compares different alternatives for composing the platform aspect models with the platform-independent model (PIM) of the application throughout the model transformation chain.

Extraction d'une architecture à base de composants depuis un système orienté objet. Une approche dirigée par les propriétés de qualité

Software architecture modeling and representation are a main phase of the development process of complex systems. In fact, software architecture representation provides many advantages during all phases of software life cycle. Nevertheless, for many systems, like legacy or eroded ones, there is no available representation of their architectures. In order to benefit from this representation, we propose, in this paper, an approach called ROMANTIC which focuses on extracting a component-based architecture of an existing object-oriented system. The main idea of this approach is to propose a quasi-automatic process of architecture recovery based on the quality characteristics of an architecture by formulating it as a search-based problem. This last acts on the space composed ofall possible architectures abstracting the object-oriented system.

Technical framework for Internetware: An architecture centric approach

Being a new software paradigm evolved by the Internet, Internetware brings many challenges to the traditional software methods and techniques. Sponsored by the national basic research program (973), researchers in China have developed an architecture centric technical framework for the definition, incarnation and engineering of Internetware. First of all, a software model for Internetware is defined for what to be, including that Internetware entities should be packaged as components, behaving as agents, interoperating as services, collaborating in a structured and on demand manner, etc. Secondly, a middleware for Internetware is designed and implemented for how to be, including that Internetware entities are incarnated by runtime containers, structured collaborations are enabled by runtime software architecture, Internetware can be managed in a reflective and autonomic manner, etc. Thirdly, an engineering methodology for Internetware is proposed for how to do, including the way to develop Internetware entities and their collaborations by transforming and refining a set of software architectures which cover all the phases of software lifecycle, the way to identify and organize the disordered software assets by domain modeling, etc.

Software estimation in the maintenance context

This article describes an extension of the Use Case Points method of software estimation. The main goal of this extension, called UCPm, is to reflect the specifics of the maintenance phase of software life cycle. UCPm takes into consideration the complexity of the base system. Then, UCPm does not consider the environmental factor as size-contributing entity and defines product size only via unadjusted use case points and technical factor. UCPm also applies four technical factors at the use case level, rather than at the level of the overall product.The method has been applied to more than 30 projects in the course of work on achieving CMM Level 4. It was found that even when requirements are not produced in the use case style, it is relatively easy to build a use case model for the purpose of estimation. It is also believed that the relatively high level of UCP/UCPm reduces the amount of work on estimation. In our preliminary estimates, one use case point maps to approximately four function points.

English

Launch vehicle projects now depend on software, more than ever before, to ensure safety and efficiency. Such critical software syfiems, which can lead to injury, destruction or loss of vital equipment, human lives, and damage to environment, must be developed and verified with high level of quality and reliability. An overview of current quality practices pursued in launch vehicle projects is presented in this paper. These practices have played a vital role in the successful launch vehicle missions of Indian Space Research Organisation. As complexity of software increases, the activity that gets affected is nothing but, software quality assurance (SQA). The SQA team is facing a lot of challenges in current practices. This paper brings out such challenges in different phases of software life cycle. A set of key points to some techniques and tools, that could contribute to meet the software quality 'assurance challenges in launch vehicle projects, are also discussed.

Progress of Research on Software Architecture

As an important means to control the complexity of software systems, to improve software quality and to support software development and software reuse, software architecture has become a mainstream research field in the software engineering community. Now, software architecture research not only focuses on the design phase, but also covers every phase of software lifecycle. This paper surveys the update-to-date research and practice of software architecture from a software lifecycle’s perspective, and discusses the potential research directions of software architecture.

An overview of guidance documents for software in metrological applications

The quality characteristics of metrological software are required by national or regional legislation, e.g., in legal metrology, or for safety critical applications, or by various standards such as software product quality standards (ISO/IEC 91261) or laboratory competence standards (ISO/IEC 170252). The parties involved are interested in getting a clear guidance for software quality requirements and validation methods. In already developed guidance documents different software quality issues, software lifecycle phases and consequences of risk evaluation for software malfunction or fraud are addressed to different extents. This paper provides a comparison of approaches with the aim to support the parties involved in understanding both the common points and the differences.

Applications of clustering techniques to software partitioning, recovery and restructuring

The artifacts constituting a software system are sometimes unnecessarily coupled with one another or may drift over time. As a result, support of software partitioning, recovery, and restructuring is often necessary. This paper presents studies on applying the numerical taxonomy clustering technique to software applications. The objective is to facilitate those activities just mentioned and to improve design, evaluation and evolution. Numerical taxonomy is mathematically simple and yet it is a useful mechanism for component clustering and software partitioning. The technique can be applied at various levels of abstraction or to different software life-cycle phases. We have applied the technique to: (1) software partitioning at the software architecture design phase; (2) grouping of components based on the source code to recover the software architecture in the reverse engineering process; (3) restructuring of a software to support evolution in the maintenance stage; and (4) improving cohesion and reducing coupling for source code. In this paper, we provide an introduction to the numerical taxonomy, discuss our experiences in applying the approach to various areas, and relate the technique to the context of similar work.

Reusing LOTOS specifications

Reuse is the process of implementing software systems using existing components. The use of formal specifications of software components produces a good characterization of their functionalities and then eases the re-usability of a module. Moreover, reuse efforts should be directed to most of the software life-cycle phases and not only to the final code of a project, which in general consumes only 10–15% of the time and the cost of the entire project. This work presents a tool supporting a method to derive the modifications of the specification of an existing module from a characterization of the environment in which the new module has to be used. The tool is integrated with the Concurrency Workbench of North Carolina, which is a well-known verification environment for process algebras.

A stochastic model of fault introduction and removal during software development

Two broad categories of human error occur during software development: (1) development errors made during requirements analysis, design, and coding activities; (2) debugging errors made during attempts to remove faults identified during software inspections and dynamic testing. This paper describes a stochastic model that relates the software failure intensity function to development and debugging error occurrence throughout all software life-cycle phases. Software failure intensity is related to development and debugging errors because data on development and debugging errors are available early in the software life-cycle and can be used to create early predictions of software reliability. Software reliability then becomes a variable which can be controlled up front, viz, as early as possible in the software development life-cycle. The model parameters were derived based on data reported in the open literature. A procedure to account for the impact of influencing factors (e.g., experience, schedule pressure) on the parameters of this stochastic model is suggested. This procedure is based on the success likelihood methodology (SLIM). The stochastic model is then used to study the introduction and removal of faults and to calculate the consequent failure intensity value of a small-software developed using a waterfall software development.

Effort estimation and prediction of object-oriented systems

Due to the growing diffusion of the object-oriented paradigm (OOP) and the need of maintaining under control the process of software development, industries are looking for metrics capable of producing satisfactory effort estimations and predictions. These metrics have to produce results with a known confidence since the early phases of software life-cycle in order to establish a process of prediction and correction of costs. To this end, specific metrics are needed in order to maintain under control object-oriented system development. In this paper, new complexity and size metrics for effort evaluation and prediction are presented and compared with respect to the most important metrics proposed for the same purpose in the literature. The validation of the most important of these metrics is also reported.

Introducing CASE tools into the software development group

Conventional groups for software development try to increase its efficiency with a more advanced approach to all phases of software life cycle. The need for more formal specifications demands the introduction of computer aided tools which base on the empirically confirmed methodologies. The most important task of CASE tools is to unite the methodologies for covering various life cycle phases under one shell. In the paper the problems, appearing in the contact of the tool with the subjects of the developers team are described.