Arbi Ghazarian

A Case Study of Defect Introduction Mechanisms

It is well known that software production organizations spend a sizeable amount of their project budget to rectify the defects introduced into the software systems during the development process. An in depth understanding of the mechanisms that give rise to defects is an essential step towards the reduction of defects in software systems. In line with this objective, we conducted a case study of defect introduction mechanisms on three major components of an industrial enterprise resource planning software system, and observed that external factors including incomplete requirements specifications, adopting new, unfamiliar technologies, lack of requirements traceability, and the lack of proactive and explicit definition and enforcement of user interface consistency rules account for 59% of the defects. These findings suggest areas where effort should be directed.

A Case Study of Source Code Evolution

Obtaining an accurate characterization of pre-release changes, especially those related to fault corrections, can give indications for the quality of the software development process and its product. The resulting indications can then be leveraged to identify areas for quality improvement within software development organizations. Towards this objective, we studied the evolution of the source code modules in an industrial enterprise resource planning software system spanning a time period of two years from the initial creation of the source code modules to the release of the software product. In this paper, we describe our case study process, and present the frequency distributions of pre-release changes and faults along with lessons learned from the case study. Overall, we found that (a) only 22% of pre-release changes contribute new functionality to the system under development; the remaining majority of the pre-release changes are either fault corrections or code clean-ups (b) over 72% of pre-release faults are propagated from upper-stream requirements and design activities (c) fault classes that are the target of most fault detection tools have a low frequency.

Characterization of functional software requirements space: The law of requirements taxonomic growth

This paper reports on a large-scale empirical multiple-case study that aimed to characterize the requirements space in the domain of web-based Enterprise Systems (ES). Results from this study, among others, showed that, on the average, about 85% of all the software functionalities in the studied domain are specified using a small core set of five requirements classes even though the results of the study hint at a larger set of nine requirements classes that should be covered. The study also uncovered a law describing the growth pattern of the emerging requirements classes in software domains. According to this law, the emergence of the classes in a requirements taxonomic scheme for a particular domain, independent of the order in which specifications of requirements in that domain are analyzed, includes a rapid initial growth phase, where the majority of the requirements classes are identified, followed by a rapid slow-down phase with periods of no growth (i.e., the stabilization phase).

Coordinated software development: A framework for reasoning about trace links in software systems

Traceability is an important factor in the success of software projects. However, achieving software traceability has proven to be costly. In this paper, we provide a root cause analysis of the cost problems in conventional traceability approaches. Based on this analysis, we propose technical criteria for a more affordable solution to the traceability problem. We then present a new framework for achieving traceability that satisfies the proposed criteria. Our approach uses coordinated software development as an enabling mechanism to support reasoning about trace links in software systems. Early evaluation of our approach shows encouraging results.

A project spine for software engineering curricular design

Software engineering education is a technologically challenging, rapidly evolving discipline. Like all STEM educators, software engineering educators are bombarded with a constant stream of new tools and techniques (MOOCs! Active learning! Inverted classrooms!) while under national pressure to produce outstanding STEM graduates. Software engineering educators are also pressured on the discipline side; a constant evolution of technology coupled with a still emerging engineering discipline. As a handson engineering discipline, where engineers not only design but also construct the technology, guidance on the adoption of project-centric curricula is needed. This paper focuses on vertical integration of project experiences in undergraduate software engineering degree programs or course sequences. The Software Enterprise, now in its 9th year, has grown from an upper-division course sequence to a vertical integration program feature. The Software Enterprise is presented as an implementation of a project spine curricular pattern, and a plan for maturing this model is given.

A Software Requirements Specification Framework for Objective Pattern Recognition: A Set-Theoretic Classification Approach

The motivation behind pattern-oriented software development is to decompose complex problems into recognizable sub-problems with predefined solutions, hence promoting both the quality of the resulting software product and the efficiency of the development process through the reuse of optimal solutions (e.g., best practices). Unfortunately, due to the opportunistic (i.e., non-systematic and subjective) element inherent in the process of recognizing conventional patterns in a problem context, the full potential of a pattern-driven problem-solving strategy has not been yet realized. In this paper, we introduce a requirements specification framework, called Problem Decomposition Scheme (PDS), which serves as a foundation to address the challenges of pattern recognition in the context of software requirements. We establish that pattern recognition can be abstracted as a set-theoretic classification problem, and formalize the properties of the resulting classification scheme. In contrast to ill-defined sub-problems in conventional development problem contexts, patterns in PDS-based specifications can be objectively recognized. To evaluate our requirements specification framework, we conducted an empirical user study of software developers performing a requirements pattern recognition task on a PDS-based requirements specification. PDS-based specifications are shown to achieve a high degree of requirements pattern recognition consistency across developers.

Detection of missing requirements using base requirements pairs

A collection of slides from the authors conference presentation is given. The following topics are discussed: functional requirement; software defect; software specification; and software requirement.

A theory of software complexity

The need for a theory of software complexity to serve as a rigorous, scientific foundation for software engineering has long been recognized. However, unfortunately, the complexity measures proposed thus far have only resulted in rough heuristics and rules of thumb. In this paper, we propose a new information theoretic measure of software complexity that, unlike previous measures, captures the volume of design information in software modules. By providing proof outlines for a number of theorems that collectively represent our current understanding and intuitions about software complexity, we demonstrate that this new, information-based formulation of software complexity is not only capable of explaining our current understanding of software complexity, but also is resilient to the factors that cause inaccuracies in previous measures.

Software enterprise pedagogy for project-based courses

The Software Enterprise is a pedagogical model combining traditional lecture with project-based learning. The Enterprise model leads students through a modular series of lessons that combine foundational concepts with skills-based competencies. In this tutorial, software engineering educators in higher education or industry will learn the methodology, get exposed to assessment techniques such as e-portfolios and concept maps, and become familiarized with the open resources available to educators that adopt the pedagogy. This tutorial should be of interest to any educator interested in making their project-based courses more engaging and more relevant to students needing to be ready to practice the profession from the first day they exit the Enterprise environment.

High development cost and software piracy: a study of motives

Every year, software piracy costs billions of dollars to organisations using software as well as those producing software. This has been intensified with the ever-increasing ease, speed, and ubiquity with which information – and software – in our hyper-connected world can be shared. This study investigates how computing students, as the future technologists and professionals, approach the piracy issue. We introduce a conceptual model for software piracy motives, derive a number of relevant hypotheses about these motives, and apply statistical tests to evaluate their validity. Among other findings, results from this study indicate that the high cost of software is a major motive for software piracy, but it cannot be directly addressed, as today’s software engineering methods, in spite of all the advances made in the discipline over the past few decades, are still not efficient enough to produce software at a substantially lower cost. This suggest a need for, and we hope opens us a discussion on, new models of software and information ownership with less economic burden for individuals.