Phases Of Software Development Research Articles

Semantic software metrics computed from natural language design specifications

An approach using semantic metrics to provide insight into software quality early in the design phase of software development by automatically analysing natural language (NL) design specifications for object-oriented systems is presented. Semantic metrics are based on the meaning of software within the problem domain. In this paper, we extend semantic metrics to analyse design specifications. Since semantic metrics can now be calculated from early in design through software maintenance, they provide a consistent and seamless type of metric that can be collected through the entire lifecycle. We discuss our semMet system, an NL-based program comprehension tool we have expanded to calculate semantic metrics from design specifications. To validate semantic metrics from design specifications and to illustrate their seamless nature across the software lifecycle, we compare semantic metrics from different phases of the lifecycle, and we also compare them to syntactically oriented metrics calculated from the source code. Results indicate semantic metrics calculated from design specifications can give insight into the quality of the source code based on that design. Also, these results illustrate that semantic metrics provide a consistent and seamless type of metric that can be collected through the entire lifecycle.

Discrete software reliability growth modeling for errors of different severity incorporating change-point concept

Several software reliability growth models (SRGM) have been developed to monitor the reliability growth during the testing phase of software development. In most of the existing research available in the literatures, it is considered that a similar testing effort is required on each debugging effort. However, in practice, different types of faults may require different amounts of testing efforts for their detection and removal. Consequently, faults are classified into three categories on the basis of severity: simple, hard and complex. This categorization may be extended to r type of faults on the basis of severity. Although some existing research in the literatures has incorporated this concept that fault removal rate (FRR) is different for different types of faults, they assume that the FRR remains constant during the overall testing period. On the contrary, it has been observed that as testing progresses, FRR changes due to changing testing strategy, skill, environment and personnel resources. In this paper, a general discrete SRGM is proposed for errors of different severity in software systems using the change-point concept. Then, the models are formulated for two particular environments. The models were validated on two real-life data sets. The results show better fit and wider applicability of the proposed models as to different types of failure datasets.

Generating Natural Language specifications from UML class diagrams

Early phases of software development are known to be problematic, difficult to manage and errors occurring during these phases are expensive to correct. Many systems have been developed to aid the transition from informal Natural Language requirements to semi-structured or formal specifications. Furthermore, consistency checking is seen by many software engineers as the solution to reduce the number of errors occurring during the software development life cycle and allow early verification and validation of software systems. However, this is confined to the models developed during analysis and design and fails to include the early Natural Language requirements. This excludes proper user involvement and creates a gap between the original requirements and the updated and modified models and implementations of the system. To improve this process, we propose a system that generates Natural Language specifications from UML class diagrams. We first investigate the variation of the input language used in naming the components of a class diagram based on the study of a large number of examples from the literature and then develop rules for removing ambiguities in the subset of Natural Language used within UML. We use WordNet, a linguistic ontology, to disambiguate the lexical structures of the UML string names and generate semantically sound sentences. Our system is developed in Java and is tested on an independent though academic case study.

Software Defect Process and Product Model for High Assurance Applications

One reason we are motivated to do this research is to suggest that it is not necessary to wait until software is fielded before recording and analyzing defects. Assuming there is an effective data collection process in place, we can record actual defects and predict future defects for all software development phases. Our contribution to defect analysis research is the modeling of the process attributes and the product reliability needed for safety critical systems in NASA, using a queuing process approach that we believe is the first of its kind.We feel this approach is important because defect process attributes, such as the time required to correct defects, have a direct bearing on product attributes, such as the number of old defects that remain unrepaired. The model has the capability of computing probabilities of defect prediction and repair, and repair timesThis feature allows unrepaired defects to be fed back into the model queue input, along with the new defects. The result provides a comprehensive template of defect processing that the software engineer can use to assess both the efficacy of defectprocessingandthereliabilityoftheproductthatistheoutcomeoftheprocess.Amajor result was that the module with the highest probability of defect detection corresponds to the modulewiththelowestvaluesofdefectcount,sourcelinesofcode,andcyclomaticcomplexity. Conversely,themodulewiththelowestprobabilitycorrespondstothemodulewiththehighest values of these attributes. Thus, the engineer would be encouraged by these results to use these relationships as a guide to predicting the probability of detection of defects on other softwaresystemswithsimilarattributes.Aremainingchallengeinthisresearch,anissuethat requires resolution, is that a coherent and comprehensive NASA defect and metrics database should be developed to support research.While the individual data items in the NASA IV&V Facility Metrics Data Program data repository are valuable, the defect data is not adequately correlated to the metrics data.

A test plan for an on-line whole building energy calculator

This paper presents the testing of a dynamic on-line whole-building energy calculator. The tool consists of a web-based interface for user inputs; an application to create the simulation input files from these user inputs; a simulation engine; and an application for passing the simulation engine output back to the interface and user. A detailed test protocol, composed of three parts, was developed as part of the software development process for quality assurance purposes. This paper will present the tasks specific to the development of the simulation engine, including, the definition of the required user inputs, the creation of default house archetypes, and the definition of the results to be presented to the user. It will also investigate the three parts of the test plan as well as the task automation tools developed to facilitate the testing. The use of these tools proved very useful given the large number of combinations of user inputs at the web interface and input files to the simulation engine. The findings show the importance of having a detailed and comprehensive test protocol during the software development phase.

Adoption of XP practices in the industry—A survey

AbstractAgile software development has recently become popular in the software industry. The methodologies in the Agile family are considered to be based on best practices. The most popular approach, Extreme Programming (XP), recommends certain best practices during the requirements gathering, implementation and testing phases of software development. In this paper, the authors analyze the best practices according to data from recent case studies and survey studies to see if and how they are followed. Metaphor was the least used practice, while unit testing was one of the most popular. Most of the practices varied across studies and projects. Agile software development is evolutionary in nature, so customizing the practices is still well within its sounds. Copyright © 2007 John Wiley & Sons, Ltd.

Supporting Software Development With Roles

Software development tools are very important in software engineering. Although roles have been acknowledged and applied for many years in several areas related to software engineering, there is a lack of research on software development tools based on roles. Most significantly, there is no complete and consistent consideration of roles in all the phases of software development. Considering the increasing importance and applications of roles in software development, this paper intends to discuss the importance of roles in software engineering and that of role-based software development; review the literature relevant to role mechanisms in software engineering; propose and describe a role-based software process; and implement a prototype tool for developing complex software systems with the help of role mechanisms

Specification of exception flow in software architectures

In recent years, various approaches combining software architectures and exception handling have been proposed for increasing the dependability of software systems. This conforms with the idea supported by some authors that addressing exception handling-related issues since early phases of software development may improve the overall dependability of a system. By systematically designing the mechanism responsible for rendering a system reliable, developers increase the probability of the system being able to avoid catastrophic failures at runtime. This paper addresses the problem of describing how exceptions flow amongst architectural elements. In critical systems where rollback-based mechanisms might not be available, such as systems that interact with mechanical devices, exception handling is an important means for recovering from errors in a forward-based manner. We present a framework, named Aereal, that supports the description and analysis of exceptions that flow between architectural components. Since different architectural styles have different policies for exception flow, Aereal makes it possible to specify rules on how exceptions flow in a given style and to check for violations of these rules. We use a financial application and a control system as case studies to validate the proposed approach.

Software Safety for Every Phase of Software Development

Where does risk management belong, at the beginning of a project or at the end? Many managers choose one or the other, or both. The correct answer is that risk management needs to be considered throughout the software development life cycle. When the risks include the safety of patients or the users of the software, the methods need to be more formal. This article will explain why, and then will provide the how and the how much.

Examining the role of iteration in the complete lifecycle of a traceability-oriented software development process

Software engineering methodologies have received considerable attention in the past few years, due to the ongoing crisis presented in the Standish Group's CHAOS Report. Royce's Waterfall Model correctly identifies the phases of software development (requirements capture, problem analysis, design, implementation, and testing), but it does not facilitate iteration between phases. Over the past several years numerous methodologies have been developed, which attempt to rectify this deficiency (e.g. the Spiral model, the Rational Unified Process (RUP), and Agile methodologies like eXtreme Programming (XP)). XP significantly differs from RUP's prescriptive approach by underemphasizing the role of explicit analysis and design artifacts, and focusing instead on techniques that quickly achieve a system. XP requires incremental augmentation of the features of a system--primarily by working at the code level, a.k.a. refactoring.

Using LabVIEW for applying mathematical models in representing phenomena

Simulations make it possible to explore physical and biological phenomena, where conducting the real experiment is impracticable or difficult. The implementation of a software program describing and simulating a given physical situation encourages the understanding of a phenomenon it self. Fifty-nine students, enrolled at the Mathematical Methods for Engineers used LabVIEW to develop software programs able to simulate physical and biological phenomena. They reported on the simulated phenomena and on the adopted strategies for its planning and the development. The works produced by the students have been analyzed taking into account the understanding of the simulated phenomenon, and the used strategy in the planning and development of the software. We found out that the more the program works, the more students understand the phenomena they simulated. The analysis of the programs and of the methodology each student used in the software development phase showed the different strategies and the cognitive styles they used and the skills that the use of LabVIEW enables learners to acquire.

보안 위협위치에서 재사용 가능한 상태전이도를 이용한 보안요구사항 식별

소프트웨어 개발 과정에서 보안 요구사항 식별은 그 중요성으로 최근에 관심이 주목되고 있다. 그러나 기존 방법들은 보안 요구사항 식별 방법과 절차가 명확하지 않았다. 본 논문에서는 소프트웨어 개발자가 보안 위협 위치의 상태전이도로부터 보안 요구사항을 식별하는 절차를 제안한다. 이과정은 상태전이도를 작성하는 부분과 어플리케이션 의존적인 보안 요구사항을 식별하는 부분으로 구성된다. 상태전이도 작성은 1) 공격자가 소프트웨어 취약성을 이용하여 자산을 공격한다는 것에 기반하여 기존에 발생했던 보안 실패 자료를 이용하여 소프트웨어의 취약성을 위협하는 위치를 식별하고, 2) 식별된 위협 위치에 해당하는 소프트웨어 취약성을 방어, 완화시킬 수 있는 상태전이도를 작성하는 과정으로 이루어진다. 어플리케이션 의존적인 보안 요구사항 식별과정은 1) 기능 요구사항을 분석 한 후, 위협 위치를 파악하고, 각 위협 위치 에 해당하는 상태전이도를 적용하고, 2) 상태전이도를 어플리케이션 의존적인 형태로 수정한 후, 3) 보안 요구사항 추출 규칙을 적용하여 보안요구사항을 작성하는 과정으로 구성된다. 제안한 방법은 소프트웨어 개발자가 소프트웨어 개발 초기에 모델을 적용하여 쉽게 보안 요구사항을 식별하는데 도움을 준다. The security requirements identification in the software development has received some attention recently. However, previous methods do not provide clear method and process of security requirements identification. We propose a process that software developers can build application specific security requirements from state transition diagrams at the security threat location. The proposed process consists of building model and identifying application specific security requirements. The state transition diagram is constructed through subprocesses i) the identification of security threat locations using security failure data based on the point that attackers exploit software vulnerabilities and attack system assets, ii) the construction of a state transition diagram which is usable to protect, mitigate, and remove vulnerabilities of security threat locations. The identification Process of application specific security requirements consist of i) the analysis of the functional requirements of the software, which are decomposed into a DFD(Data Flow Diagram; the identification of the security threat location; and the appliance of the corresponding state transition diagram into the security threat locations, ii) the construction of the application specific state transition diagram, iii) the construction of security requirements based on the rule of the identification of security requirements. The proposed method is helpful to identify the security requirements easily at an early phase of software development.

An exploratory study of risks in information system development projects: using association rule mining

A better understanding of the distinguishing characteristics of risks in different software development phases is vital if we are to reduce the possibility of project failure. This paper explores the relationships among major system development risks, considering the development stages during which an individual risk factor with critical impact on system development projects, occurs. The survey data collected from system development experts in Korea was analysed using association rule mining, which is one of the best-known data mining methods. The findings from the association rules among the risks presented distinctive features of risks in terms of individual development phases. The results of this research should be valuable for industrial practitioners in understanding the risk occurrence mechanism in each development stage and to mitigate the difficulties in advance.

On translating UML models into graph transformation systems

In this paper we present a concept of a rigorous approach that provides a formal semantics for a fundamental subset of UML. This semantics is derived by translating a given UML model into a graph transformation system, allowing modelers to actually execute their UML model. The graph transformation system comprises graph transformation rules and a working graph which represents the current state of the modeled system. In order to support UML models which use OCL, we introduce a specific graph transformation approach that incorporates full OCL in the common UML fashion. The considered UML subset is defined by means of a metamodel similar to the UML 1.5 metamodel. The concept of a system state that represents the state of the system at a specific point in time during execution is likewise introduced by means of a metamodel. The simulated system run is performed by applying graph transformation rules on the working graph. The approach has been implemented in a research prototype which allows the modeler to execute the specified model and to validate the basic aspects of the model in an early software development phase.

임베디드 소프트웨어의 소스 코드 품질 향상을 위한 Practice Patterns의 적용

임베디드 소프트웨어는 하드웨어 플랫폼에 탑재하기 전, 소스 코드에 대한 품질을 검증하는 작업이 매우 중요하다. 임베디드 소프트웨어의 코드 품질을 향상시키기 위해서는 분석 및 설계 단계의 모델에 대한 품질과 생성된 코드에 대한 품질이 관리되어야 한다. 본 연구에서는 임베디드 소프트웨어의 소스 코드 품질을 향상시키기 위한 방법으로 Practice Pattern을 제안한다. 이는 모델링 과정이나 코딩 과정에서 개발자를 가이드 하는 절차 패턴으로써, 모델의 품질과 소스 코드 품질을 향상시키는 방법으로 사용될 수 있다. 제시하는 패턴의 적용은 기능의 정확성뿐만 아니라 성능, 모듈화, 재사용성 및 이식성 등과 같은 품질 요소들을 향상시킬 수 있을 것으로 보인다. Source code quality is very Important that software embedded into product is difficult to change. In order to improve source code quality, it should be considered the quality of analysis and design models as well as the quality of source code. In this paper, we suggest 'Practice Pattern' as one of practical techniques to improve embedded software source code quality. Practice pattern is a procedural pattern to guide modeling and coding activities in software development phases. We believe that applying our pattern provides the improvement of optimum performance, modularization, and portability for embedded software source code.

Design-level performance prediction of component-based applications

Server-side component technologies such as Enterprise JavaBeans (EJBs), .NET, and CORBA are commonly used in enterprise applications that have requirements for high performance and scalability. When designing such applications, architects must select suitable component technology platform and application architecture to provide the required performance. This is challenging as no methods or tools exist to predict application performance without building a significant prototype version for subsequent benchmarking. In this paper, we present an approach to predict the performance of component-based server-side applications during the design phase of software development. The approach constructs a quantitative performance model for a proposed application. The model requires inputs from an application-independent performance profile of the underlying component technology platform, and a design description of the application. The results from the model allow the architect to make early decisions between alternative application architectures in terms of their performance and scalability. We demonstrate the method using an EJB application and validate predictions from the model by implementing two different application architectures and measuring their performance on two different implementations of the EJB platform.

Architecture-based software reliability modeling

Reliability is one of the essential quality requirements of software systems, especially for life critical ones. Software reliability modeling provides a means for estimating reliability of software, which facilitates effective decision making for quality control. Existing models either use a black-box approach that is based on test data of the whole system or a white-box approach that uses components’ reliabilities and inter-component interactions. While the black-box approach is applicable to the late phases of software development, the white-box approach can support decisions on early component reuse and later component upgrades and updates. However, the white-box based models have traditionally considered only homogeneous software behaviors. For this reason, we extended the white-box to an architecture-based approach, utilizing the characteristics of architectural styles to capture design information and to realize non-uniform heterogeneous software behaviors. Adhered to the behaviors, a state machine of a discrete-time Markov model is constructed and employed to compute software reliability. Our approach allows reliability to be modeled at architectural design stage to decide components for reuse as well as later testing and maintenance phases for continuous software evolution. In contrast to the black-box approach, the model only needs to retest the influenced portions for a behavioral or structural change, instead of the complete system. This model yields a compelling result after being applied to an industrial real-time component-based financial system. We believe that this architecture-based modeling technique can have a great potential for use to effectively improve software quality.

Defining a Requirements Process Improvement Model

Both software organisations and the academic community are aware that the requirements phase of software development is in need of further support. We address this problem by creating a specialised Requirements Capability Maturity Model (R-CMM1). The model focuses on the requirements engineering process as defined within the established Software Engineering Institute’s (SEI’s) software process improvement framework. Our empirical work with software practitioners is a primary motivation for creating this requirements engineering process improvement model. Although all organisations in our study were involved in software process improvement (SPI), they all showed a lack of control over many requirement engineering activities.This paper describes how the requirements engineering (RE) process is decomposed and prioritised in accordance with maturity goals set by the SEI’s Software Capability Maturity Model (SW CMM). Our R-CMM builds on the SEI’s framework by identifying and defining recommended RE sub-processes that meet maturity goals. This new focus will help practitioners to define their RE process with a view to setting realistic goals for improvement.

Modeling Design/Coding Factors That Drive Maintainability of Software Systems

It is cost-effective for software practitioners to monitor and control quality of software systems from the early phases of development. Assessing and modeling the effects of design and coding factors on software system maintainability can help provide heuristics to human designers and programmers to reduce maintenance costs and improve quality. This paper presents a study based on intuitive and experimental analyses that use a suite of twenty design/code measures to obtain indications of their effect on maintainability. This paper lists several important contributions of the work, one of which is the investigation of an unprecedentedly large number of systems (fifty) in a single study. The previous related studies on the other hand, have investigated 2--8 systems. The results reported in this paper using experimental procedures are unique, many of which have not been empirically established in the previous literatures, and are interesting because they are not normally intuitively obvious in most cases. The study also serves to empirically validate those results that seem to be intuitive. The results of the study indicate a number of promising effects of design and coding factors on system maintainability. The use of the results from the relatively early phases of software development could significantly help practitioners to improve the quality of systems and thus optimize maintenance costs.

Design, synthesis and verification of a smart imaging core using SystemC

In this paper the development of a smart imaging core following a SystemC-based design flow is presented. The smart imaging core integrates an ARM processor and two specific hardware blocks for image processing: a smart imaging coprocessor and a motion estimation coprocessor. A SystemC-based design flow is applied, comprising the design, synthesis and verification and synthesis of the two coprocessors, as well as the development and integration of the embedded software on the smart imaging core. The two coprocessors are successfully modeled and refined from C/C++-based algorithmic descriptions down to architecture reference models using SystemC and TLM concepts. For the RTL implementation of the coprocessor hardware high-level synthesis tools are used. The applied SystemC-based design flow enabled the iterative refinement of the architecture towards an optimal RTL implementation. Furthermore, the use of SystemC TLM supports the integration of fast functional models of the coprocessors on a virtual prototype platform of the target architecture. This virtual prototype is beneficially used during the embedded software development phase.