Real Software Development Projects Research Articles

FORMATION OF COMPETENCIES OF COLLECTIVE SOFTWARE DEVELOPMENT OF STUDENTS IN THE FIELD OF INFORMATION TECHNOLOGY IN THE PROCESS OF USING FREE SOFTWARE

The article analyzes the existing systems that provide an opportunity for collective software development by students of information technology and offers recommendations for their use in the educational process. In the authors' opinion, it is advisable to use free versions of the Atlassian stack (Jira, Bitbucket, Confluence), which allows forming professional competencies in collaborative software development of future specialists, while the limitations of free versions are not critical for educational purposes.
 The concept of the competence of collective software development of an information technology specialist is formulated, by which we mean the integrated ability of an individual to effectively solve software development tasks in the process of teamwork in professional activities.
 It has been found that software development requires the implementation of many steps, from defining requirements to testing and releasing a product. In the process of forming a collective software development of an information technology specialist, cloud services and other systems (Bitbucket, GitHub, GitLab, Jira, Asana, Basecamp, Mantis, Bugzilla, etc.) are used.
 Training future IT professionals in the development process and involvement in real software development projects will help them acquire, develop, and improve their collaborative software development competencies.

Characterization of continuous experimentation in software engineering: Expressions, models, and strategies

Continuous Experimentation (CE) has become increasingly popular across industry and academic communities. Major software organizations use CE to increase their revenue by adding value to end-users, and researchers are investigating the CE adoption process and usage to expand its success. Given this rapid evolution, observing a shared understanding of CE definitions, processes, and experiment strategies is difficult, potentially jeopardizing new implementations and focused research efforts. To characterize CE from the perspective of its definitions, processes, and strategies for experimentation available in the technical literature and to evolve the understanding perspectives for “continuous experimentation” and “data-driven development” definitions. To select and analyze sources of information in the technical literature dealing with different aspects of continuous experimentation through a Literature Study using an ad hoc search improved with snowballing (backward and forward). Organize the findings into new perspectives for CE definitions, processes, and experiment strategies. It was possible to identify many different definitions, processes, and experimental strategies used to describe CE in the 72 analyzed empirical papers, making it difficult to decide on their combination to be applied in a real software development project. Therefore, it has been proposed to evolve the CE understanding perspective, to categorize its experiment strategies, and to offer a combined development process for CE combining parts of other processes. Besides, conjectural requirements have been identified, which can contribute to better differentiating requirements and hypotheses in the CE context. Likely, a better understanding of CE is still missing. It can contribute towards organizing a common taxonomy to facilitate the possible choices for the experiment strategies. Therefore, there is space for more investigations on its applicability and value in different categories of software systems, despite all the advancements of CE and its promotion in developing modern software systems.

A Comprehensive Analysis of Proportional Intensity-Based Software Reliability Models with Covariates

This paper focuses on the so-called proportional intensity-based software reliability models (PI-SRMs), which are extensions of the common non-homogeneous Poisson process (NHPP)-based SRMs, and describe the probabilistic behavior of software fault-detection process by incorporating the time-dependent software metrics data observed in the development process. The PI-SRM is proposed by Rinsaka et al. in the paper “PISRAT: Proportional Intensity-Based Software Reliability Assessment Tool” in 2006. Specifically, we generalize this seminal model by introducing eleven well-known fault-detection time distributions, and investigate their goodness-of-fit and predictive performances. In numerical illustrations with four data sets collected in real software development projects, we utilize the maximum likelihood estimation to estimate model parameters with three time-dependent covariates (test execution time, failure identification work, and computer time-failure identification), and examine the performances of our PI-SRMs in comparison with the existing NHPP-based SRMs without covariates. It is shown that our PI-STMs could give better goodness-of-fit and predictive performances in many cases.

Lean requirements traceability automation enabled by model-driven engineering.

BackgroundThe benefits of requirements traceability, such as improvements in software product and process quality, early testing, and software maintenance, are widely described in the literature. Requirements traceability is a critical, widely accepted practice. However, very often it is not applied for fear of the additional costs associated with manual efforts or the use of additional tools.MethodsThis article presents a “low-cost” mechanism for automating requirements traceability based on the model-driven paradigm and formalized by a metamodel for the creation and monitoring of traces and an integration process for traceability management. This approach can also be useful for information fusion in industry insofar that it facilitates data traceability.ResultsThis article extends an existing model-driven development methodology to incorporate traceability as part of its development tool. The tool has been used successfully by several companies in real software development projects, helping developers to manage ongoing changes in functional requirements. One of those projects is cited as an example in the paper. The authors’ current work leads them to conclude that a model-driven engineering approach, traditionally used only for the automatic generation of code in a software development process, can also be used to successfully automate and integrate traceability management without additional costs. The systematic evaluation of traceability management in industrial projects constitutes a promising area for future work.

Cultivating the Ideal Teamwork through Real Software Development Project Experience

It is proven by many studies that software project failures are driven by not just from a single reason but multiple factors, combined and somehow closely related to each other. Basically, failure in projects is when the software developed is not delivered within time, within stipulated budget and of poor quality. All these rooted from poor project management and certainly in agreement with findings reported in the literature. Realizing the importance of this aspect in ensuring software project success, this paper presents our efforts in preparing future software practitioners to become readily equipped especially with teamwork essence through gaining real project work experience with the industry. Emphasizing the application of Teamwork Quality (TWQ) constructs, we invited several software houses to be part of our teaching plan and assigned our students in 12 teams from SSE4301 course to the projects initiated by each company. 14 weeks duration of coursework were given to these students to carry out their projects and at week 15 they delivered a presentation of their product in front of the industrial supervisors, lecturers and the rest of the class for assessment. Our premise is ideal teamwork influences the success of a software project. We believe this small effort capable to instill and cultivate ideal teamwork among the students when dealing with real clients and different set of expectations. Apart from that, we hope the implementation of our teaching plan that incorporated the industry involvement directly would be able to transform and elevate the landscape of teaching and learning we have been practicing for all these years.

Elaborating Validation Scenarios Based on the Context Analysis and Combinatorial Method: Example of the Power-Efficiency Framework Innomterics

The preliminary task of a project consists of the definition of the scenarios that will guide further development work and validate the results. In this paper, we present an approach for the systematic generation of validation scenarios using a specifically developed taxonomy and combinatorial testing. We applied this approach to our research project for the development of the energy-efficiency evaluation framework named Innometrics. We described in detail all steps for taxonomy creation, generation of abstract validation scenarios, and identification of relevant industrial and academic case studies. We created the taxonomy of the target computer systems and then elaborated test cases using combinatorial testing. The classification criteria were the type of the system, its purpose, enabling hardware components and connectivity technologies, basic design patterns, programming language, and development lifecycle. The combinatorial testing results in 13 cases for one-way test coverage, which was considered enough to create a comprehensive test suite. We defined the case study for each particular scenario. These case studies represent the real industrial, educational, and open-source software development projects that will be used in further work on the Innometrics project.

A multiobjective optimization method considering process risk correlation for project risk response planning

Project risk response planning is an important component of project risk management to help ensure project success. However, thus far, the relevant research has ignored the correlations between risk factors during different project development subprocesses. This study proposes a novel risk response method by opening the black box of the project process and considering the risk correlations among different subprocesses to help practitioners create a practical risk response plan. In our method, we first identify process risk factors from two-dimensional criteria called risk categories and project development subprocesses. Then, we consider the risk correlations between different subprocesses to assess the true effect of each process risk factor. Finally, we build a multiobjective risk response model under resource constraints to minimize the total expected losses, the total expected schedule delay, and the total expected quality reduction. Based on the model, we obtain a set of Pareto-optimal risk response plans. Project managers can select a satisfactory risk response plan based on their experience and objective project requirements. Finally, we apply the proposed method to a real software development project. We find that the risk response effects are better if managers control the process risks earlier. Moreover, the number of initial risk factors in each subprocess is an important reference in risk response resource allocation.

Modelo para la Inserción de Estudiantes Universitarios de la Universidad Tecnológica de Panamá en Proyectos de Desarrollo de Software

The Software Factory of the ICT Research Center is currently implementing a research model that consists in the incorporation of undergraduate students of the Technological University of Panama in software development projects. This model aims to promote the participation of university students on real software development projects, and to build a research culture. The model consists of five phases: Project planning, selection of students, provide a 45-hour training to selected students on ICT Research Center development guidelines, assign and insert students in software projects (they will also be assigned to a mentor), and give the opportunity to high performance students to be recruited by an ICT Research group. It should be noted that student participation is voluntary, so they do not receive final compensation.Keywords: Student's insertion, volunteering, software development

A Fuzzy based Model for Effort Estimation in Scrum Projects

This paper aims to utilize the fuzzy logic concepts to improve the effort estimation in Scrum framework and in turn add a significant enhancement to Scrum. Scrum framework is one of the most popular agile methods in which the team accomplishes their work by breaking down the work into a series of sprints. In Scrum, there are many factors that have a significant influence on the effort estimation of each task in a Sprint. These factors are: Development Team Experience, Task Complexity, Task Size, and Estimation Accuracy. These factors are usually presented using linguistic quantifiers. Therefore, this paper utilizes the fuzzy logic concepts to build a fuzzy based model that can improve the effort estimation in Scrum framework. The proposed model includes three components: fuzzifier, inference engine, and defuzzifier. In addition, the proposed model takes into consideration the feedback that is resulted from comparing the estimated effort and the actual effort. The researcher designed the proposed model using MATLAB. The proposed model is applied on three Sprints of a real software development project to present how the proposed model works and to show how it becomes more accurate over time and gives a better effort estimation. In addition, the Scrum Master and the development team can use the proposed model to monitor the improvement in effort estimation accuracy over the project life.

Avoiding code pitfalls in Aspect-Oriented Programming

Aspect-Oriented Programming (AOP) is a maturing technique that requires a good comprehension of which types of mistakes programmers make during the development of applications. Unfortunately, the lack of such knowledge seems to represent one of the reasons for the cautious adoption of AOP in real software development projects. This paper reports on the results of a series of experiments whose main goal is to analyze and catalogue code pitfalls that are likely to lead programmers to make mistakes in AOP refactoring. Each experiment consists of a task that requires the aspectization of a crosscutting concern in one object-oriented application. Eight rounds of the experiment provided us with data of 98 AOP implementations from four crosscutting concerns in four different applications. Each participant of the experiment produced one implementation. Based on the analysis of these implementations, we (i) document six categories of recurring mistakes made by programmers, (ii) correlate these mistakes with the programmer expertise in object-oriented programming, years of software development, and pair programming, and (iii) derive a catalogue of code pitfalls which are likely to lead programmers to make the documented mistakes. We apply significance tests in order to statistically evaluate our results. We also present a prototype tool to warn programmers of the code pitfalls during refactoring activities.

Empirical Assessments of a tool to support Web usability inspection


 
 
 Usability is one of the most important software quality attributes regarding its acceptability by end users. It is even more important in the context of Web applications. One way of evaluating application usability is through inspections. The WDP (Web Design Perspectives- based Usability Inspection Technique) presents evidence of industrial use feasibility; however some computerized support had been suggested by practitioners. Therefore, the WDP Tool was built, aiming to provide automated support the WDP technique application, reducing the effort involved in usability inspections with WDP. This paper presents two observational studies regarding the use of the WDP Tool use, one in vivo and one in vitro, which aimed to analyze the cost-effectiveness of its application and its appropriateness to the industrial environment through the Technology Acceptance Model (TAM). The results provide indications about the feasibility of using the WDP Tool to support usability inspections in real software development projects in the industry.
 
 

Research on Logistics Software Design and Development Process Bases on Organizational Learning

This paper describes a cycle in which organizational learning and software development serve each other, presents the concept of organizational learning cycle method. Experience in a real software development project has led us to identify several key challenges for software design and development through organizational learning. A discussion of these challenges presents steps taken toward addressing them, as well as barriers remaining.

A contingency estimation model for software projects

A contingency estimation model for software development projects is presented. The proposed model considers the estimated cost and the risk of software projects to estimate contingency resources; hence, contingency estimates are correlated to the cost and risk of software projects. The model uses a generic probabilistic representation of the estimated cost; hence, it can be deployed with any project development environment and provides a flexible choice to software managers. Furthermore, the proposed model considers the risk tolerance of software organizations to estimate the contingency and helps to abate the maximum impacts of risk events within the risk tolerance. The proposed model is scalable to a portfolio of software projects. The model produces sub-additive contingency estimates which is essential to optimize a software project or a portfolio of software projects. The results of a case-study show that the contingency estimates are comparable with the actual contingency resources needed for the development of real software development projects.

Two-Layer Wrapping for COTS Software Integration: An Experience with Matlab

Although commercial-off-the-shelf (COTS) product integration presents clear advantages in a variety of engineering fields, several problems can arise in part due to their heterogeneous nature. Little research addresses the integration of particular COTS to specific domains. A University of Vigo project for reusable software development in the engineering domain adopted this approach. The underlying hypothesis was that making COTS integration easier would facilitate the development of domain-specific applications. The solution consists of a two-layer wrapping approach. The first layer captures the COTS domain model, facilitating integration of general-purpose functionality. A second layer provides better integration of more domain-specific functionality. Several real software development projects have used the proposed solution, and the results yielded notable effort savings, showing the approach's utility in reducing COTS integration efforts.

Using Artificial Neural-Networks in Stochastic Differential Equations Based Software Reliability Growth Modeling

Due to high cost of fixing failures, safety concerns, and legal liabilities, organizations need to produce software that is highly reliable. Software reliability growth models have been developed by software developers in tracking and measuring the growth of reliability. Most of the Software Reliability Growth Models, which have been proposed, treat the event of software fault detection in the testing and operational phase as a counting process. Moreover, if the size of software system is large, the number of software faults detected during the testing phase becomes large, and the change of the number of faults which are detected and removed through debugging activities becomes sufficiently small compared with the initial fault content at the beginning of the testing phase. Therefore in such a situation, we can model the software fault detection process as a stochastic process with a continuous state space. Recently, Artificial Neural Networks (ANN) have been applied in software reliability growth prediction. In this paper, we propose an ANN based software reliability growth model based on Ito type of stochastic differential equation. The model has been validated, evaluated and compared with other existing NHPP model by applying it on actual failure/fault removal data sets cited from real software development projects. The proposed model integrated with the concept of stochastic differential equation performs comparatively better than the existing NHPP based model.

EvolTrack: improving design evolution awareness in software development

Abstract Software differs from most manufactured products because it is intangible. This characteristic makes it difficult to detect, control, and understand how it evolves. This paper presents an approach based on software visualization that can detect and externalize design evolution made in a software project during its initial development or at any further phase. By using this approach, a developer can be aware of the current state of the software as a whole and can additionally verify if the current design, also called emerging design, is evolving according to the team expectations and leader guidance, preventing problems caused by misunderstandings of the expected software solution. The approach was evaluated with free/open source software (FOSS) projects. The results indicate that the approach behaves as expected when applied to real software development projects, with minor performance bottlenecks.

Software Reliability Growth Models Incorporating Change Point With Imperfect Fault Removal and Error Generation

The number of faults removed need not always be same as the number of failures observed in real software development environment. If number of failures observed is more than number of faults removed then we have the case of imperfect debugging. Due to complexity of software system and incomplete understanding of software, testing team may not be able to remove the fault perfectly on detection of failure and the original fault may remain leading to imperfect fault removal, or get replaced by another fault/error causing error generation. Attempts have been made to study the above cases separately. Most of the SRGMs are based upon constant or monotonically increasing fault detection rate (FDR). In practice, as testing grows, so does skill and efficiency of the testers. With introduction of new testing strategies and new test cases, there comes a change in FDR. The time point where the change in removal curve appears is termed as “change point”. In this paper, we incorporate the concept of change point in software reliability growth in presence of imperfect fault removal and error generation. The models have been validated, evaluated and compared with other existing NHPP models by applying it on actual failure/fault removal data sets cited from real software development projects.

Taguchi methods in software quality testing

Quality optimisation methods offer a structured way of improving software development as early as in the product design phase. This work introduces the Taguchi method in software design optimisation. The basics of the method are reviewed along with a proposed methodology for design of experiments (DOE). A case study is drawn from a real software development project in the area of industrial simulations. One critical quality characteristic in simulations software is the software performance. A key performance metric, the code total execution time, is selected to monitor experimentally performance variation. Taguchi's DOE is employed to provide a practical relationship between code structure factors and factor interactions and the performance metric. The run-time performance evaluation of two alternate versions of multiple loop-nesting are analysed by Taguchi's signal-to-noise ratio (SNR) concept. The purpose of the paper was to insinuate the usefulness of these statistical tools in assessing software quality metrics based on a scientific approach. It is demonstrated that performance optimisation enhances execution time by a factor of three with respect to the expected value.

Gompertz software reliability model: Estimation algorithm and empirical validation

Gompertz curve has been used to estimate the number of residual faults in testing phases of software development, especially by Japanese software development companies. Since the Gompertz curve is a deterministic function, the curve cannot be applied to estimating software reliability which is the probability that software system does not fail in a prefixed time period. In this article, we propose a stochastic model called the Gompertz software reliability model based on non-homogeneous Poisson processes. The proposed model can be derived from the statistical theory of extreme-value, and has a similar asymptotic property to the deterministic Gompertz curve. Also, we develop an EM algorithm to determine the model parameters effectively. In numerical examples with software failure data observed in real software development projects, we evaluate performance of the Gompertz software reliability model in terms of reliability assessment and failure prediction.

SOFTWARE RELIABILITY ASSESSMENT USING ARTIFICIAL NEURAL NETWORK BASED FLEXIBLE MODEL INCORPORATING FAULTS OF DIFFERENT COMPLEXITY

With growth in demand for zero defects, predicting reliability of software products is gaining importance. Software Reliability Growth Models (SRGM) are used to estimate the reliability of a software product. We have a large number of SRGM; however none of them works across different environments. Recently, Artificial Neural Networks have been applied in software reliability assessment and software reliability growth prediction. In most of the existing research available in the literature, it is considered that similar testing effort is required on each debugging effort. However, in practice, different amount of testing efforts may be required for detection and removal of different type of faults on basis of their complexity. Consequently, faults are classified into three categories on basis of complexity: simple, hard and complex. In this paper we apply neural network methods to build software reliability growth models (SRGM) considering faults of different complexity. Logistic learning function accounting for the expertise gained by the testing team is used for modeling the proposed model. The proposed model assumes that in the simple faults the growth in removal process is uniform whereas, for hard and complex faults, removal process follows logistic growth curve due to the fact that learning of removal team grows as testing progresses. The proposed model has been validated, evaluated and compared with other NHPP model by applying it on two failure/fault removal data sets cited from real software development projects. The results show that the proposed model with logistic function provides improved goodness-of-fit for software failure/fault removal data.