Large-scale Software Projects Research Articles

Analytics-Driven Dashboards Enable Leading Indicators for Requirements and Designs of Large-Scale Systems

Mining software repositories using analytics-driven dashboards provides a unifying mechanism for understanding, evaluating, and predicting the development, management, and economics of large-scale systems and processes. Dashboards enable measurement and interactive graphical displays of complex information and support flexible analytic capabilities for user customizability and extensibility. Dashboards commonly include system requirements and design metrics because they provide leading indicators for project size, growth, and volatility. This article focuses on dashboards that have been used on actual large-scale software projects as well as example empirical relationships revealed by the dashboards. The empirical results focus on leading indicators for requirements and designs of large-scale software systems based on insights from two sets of software projects containing 14 systems and 23 systems.

A discrete event simulation model in the case of managing a software project

The design and development of large-scale software projects is a complex endeavor, often facing problems like cost and schedule overruns as well as low quality. Over the last years the management of software development projects has been recognized as the cornerstone point of seeking improvement and solutions. Simulation modeling of the software project process is gaining interest among academics and practitioners, as a method to tackle the complex questions with which relevant enterprises are confronted. It offers support on several issues, such as defining software product development strategies, decision-making regarding process improvement and training, in a time span ranging from a short portion of the life cycle to long term product evolution, with organization-wide implications. The aim of this work is to implement a model simulating a core part of a software project process, enabling the estimation of several project development details such as delivery times and quality metrics. The purpose of the model is to assist project managers in control and monitoring, but also in identifying the best planning alternatives. The model scope covers a portion of the life cycle of an incremental software development venture.

Ignominy: tool for analysing software dependencies and for reducing complexity in large software systems

LHC experiments such as CMS have large-scale software projects that are challenging to manage. We present Ignominy, a tool developed in CMS to help us deal better with complex software systems. Ignominy analysis the source code as well binary products such as libraries and programs to deliver a comprehensive view of the package dependencies, including all the external products used by the project. We describe the analysis and the various charts, diagrams and metrics collected by the tool, including results from several large-scale HEP software projects. We also discuss the progress made in CMS to improve the software structure and the experience we have gained in physical packaging and distribution of our code.

Engineers don't build [software development

Most of us never approach a construction project with a software development methodology. However, construction projects exhibit much higher success rates than software development projects. The author identifies the "master-builder" approach taken by most software development projects where the developers assume the role of architect, engineer, builder, and inspector. Most large-scale construction projects abandoned the approach nearly 100 years ago. Why do we do it for large-scale software projects? Engineers design systems or buildings, and programmers or builders implement them. That approach yields greater success rates in terms of quality, time, and budget.

Software metrics knowledge and databases for project management

The construction and maintenance of large, high-quality software projects is a complex, error-prone and difficult process. Tools employing software database metrics can play an important role in the efficient execution and management of such large projects. In this paper, we present a generic framework to address this problem. This framework incorporates database and knowledge-base tools, a formal set of software test and evaluation metrics, and a suite of advanced analytic techniques for extracting information and knowledge from available data. The proposed combination of critical metrics and analytic tools can enable highly efficient and cost-effective management of large and complex software projects. The framework has the potential for greatly reducing venture risks and enhancing production quality in the domain of large-scale software project management.

Implementing risk management on software intensive projects

Rising costs, falling performance, and slipping schedules are common problems on large scale software projects. The authors describe key risk issues and how they were mitigated in one DoD (military) project.

Selecting software subcontractors

Large-scale software projects place special demands on the developing organization and can require much greater participation by outside companies. The authors describe their methods for selecting subcontractors for a large project in which outside companies are supplying 90 percent of the code.

Large-scale project management is risk management

Because large-scale software projects increasingly affect the public good, the "normal science" paradigm is proving insufficient to model their complexity and potential consequences. The "postnormal science" paradigm offers a better fit, using a robust management approach predicated on a risk-taking ethic.

Understanding the factors influencing the performance of software development groups: An exploratory group-level analysis

The increasing complexity and size of software systems makes the performance and productivity of the software development activity a critical issue. Most studies of software development performance to date have focused on individual software developers. However, software development, especially for large-scale software projects, is a group effort in which the characteristics of the group itself play an important role. The paper examines the variation in the performance of software development groups as a function of the characteristics of the group itself. Using data from 31 software development groups, we examined the influence of the group's cohesiveness, total experience in software development and capability on the group's performance level. The influence of cohesiveness and capability was found to be strong and significant while the influence of experience was the weakest. The results from this exploratory research provide interesting insights into the issue of software development performance and offer important implications for development teams working on software projects.

The design of knowledge-based systems for managing Ill-structured software projects

Current planning and control procedures for large-scale software projects are not sufficiently equipped to deal with changing or imprecise requirements, resource breakdowns, unexpected delays, etc. We propose a solution for managing change in projects, based on a semantic model of the software design and development processes. At the heart of this technique is the formation of islands of project knowledge in a way that facilitates dealing with most design and plan revisions locally. A protocol for interactive change management is presented that advocates need-based formation of coalitions between islands as a means for graceful degradation in the place of strict hierarchical control. The results of initial empirical investigations of the usability of the approach and plans for its continuing evaluation are also reported.

On teaching operating systems

This paper discusses teaching an Operating Systems Course. Different approaches to teaching the course are presented. An operating systems course is one of the kernel courses in computer curriculum of both China and other countries. This course is of critical importance for students to understand the working procedures and principles of modern computer systems, to understand the methodology and approach of the design of system software, and to gain an appreciation for the requirements of other large-scale software projects.

Computer-aided software development process design

The authors describe an intelligent tool designed to aid managers of software development projects in planning, managing, and controlling the development process of medium- to large-scale software projects. Its purpose is to reduce uncertainties in the budget, personnel, and schedule planning of software development projects. It is based on dynamic models for the software development and maintenance life-cycle process. This dynamic process is composed of a number of time-varying, interacting developmental phases, each characterized by its intended functions and requirements. System dynamics is used as a modeling methodology. The resulting software life-cycle simulator (SLICS) and the hybrid expert simulation system of which it is a subsystem are described.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

An intelligent dynamic simulation model for designing software development processes

This paper describes a computer-aided software development process design. This is a computerized intelligent tool designed to aid managers of software development projects in planning, managing and controlling the development process of medium to large scale software projects. The application of this computerized tool should help reduce the uncertainties involved in the budget, personnel and schedule planning of software development projects.

Software: Artificial-intelligence applications appear at last large-scale software projects gain tools strategic defense initiative presses on

Three major developments are examined. The first is the proliferation of artificial intelligence (AI) applications, which moved last year to establish itself as a practical tool. The emphasis was on business and financial uses, but some engineering troubleshooting aids also emerged. A significant development was the spread of AI software capable of running on many different hardware platforms tools for large-scale software projects (programming in the large) emerged in greater numbers. The tools include design and specification languages, coding tools, and integration tools. 1986 was also the year that many consortiums got down to business: hiring staff, setting directions, and beginning to work. The controversy surrounding the issue of reliable software for the Strategic Defense Initiative is briefly considered.

Software reliability estimation: A realization of competing risk

A software reliability model presented here assumes a time-dependent failure rate and that debugging can remove as well as add faults with a nonzero probability. Based on these assumptions, the expected number of faults and mean standard error of the estimated faults remaining in the system are derived. The model treats the capability of correcting errors as a random process under which most of the existing software reliability models become special cases of this proposed one. It, therefore, serves to realize a competing risk problem and to unify much of the current software reliability theory. The model deals with the nonindependence of error correction and should be extremely valuable for a large-scale software project.

A proposed 4-year software engineering curriculum

Computer science and engineering (CSE) departments in the nation's universities are the current targets of much criticism by software professionals. The common complaint is that the existing curricula do not relate to many of the most important problems a software engineer faces in the industrial/business environment. If we define software engineering as the establishment and application of sound engineering principles to obtain economically software that is reliable and works efficiently on real machines, it is mandatory that we recognize software engineering as more than simply converting a given set of program specifications into executable code. The software engineer must deal with the entire software life cycle which spans the time from the conception of the product, through the development phase, and finally to the end of its operational life. Medium- to large-scale software projects typically involve a myriad of managers, engineers, programmers, and customers which leads to the need for effective management and communications to ensure the best possible product. Therefore, the software engineering curriculum must include the following basic education areas: computer science and engineering, management science, communication skills, and problem solving in addition to fundamental physical and business sciences. Disparities between academic attitudes and profit-making realities are described and fundamental elements of an effective curriculum are proposed in this paper. A suggested 4-year curriculum leading to a Bachelor of Science degree in Software Engineering is also presented.

Some experience with automated aids to the design of large-scale reliable software

This paper summarizes some recent experience in analyzing and eliminating sources of error in the design phase of large software projects. It begins by pointing out some of the significant differences in software error incidence between large and small software projects. The most striking contrast, illustrated by project data, is the large preponderance of design errors over coding errors on large-scale projects, not only with respect to numbers of errors, but also with respect to the relative time and effort required to detect them and correct them. The paper next presents a taxonomy of software error causes, and some analyses of the design error data, performed to obtain a better understanding of the nature of large-scale software design errors and to evaluate alternative methods of preventing, detecting, and eliminating them. Based on this analysis of observational data, a hypothesis was derived regarding the potential cost-effectiveness of an automated aid to detecting inconsistencies between assertions about the nature of inputs and outputs of the various elements (functions, modules, data bases, data sources, etc.) of the software design. This hypothesis was tested by developing a prototype version of such an aid, the Design Assertion Consistency Checker (DACC), using TRW's Generalized Information Management (GIM) system, and using it on a large-scale software project with 186 elements and 967 assertions about their inputs and outputs. Of the 121,000 possible mismatches between input and output assertions, DACC found 818, at a cost in computer time of $30. Most of the mismatches resulted from shortfalls in the initial version of DACC or the initial data preparation, such as a lack of a synonym capability and a lack of a explicit statements about external inputs and outputs. However, a number of serious mismatches were exposed at a time when they were easy to correct, and a most useful work-list generated of items needing resolution before allowing the design effort to proceed to further detail. In general, the data confirmed the hypothesis about the general utility of a DACC capability for large software projects. However, a number of additional features should be considered to compensate for current deficiencies (in areas such as manuscript preparation) and to fully take advantage of having the software design in machine-readable form.