Ahmed Abd-Allah, "Extending Reliability Block Diagrams to Software Architectures" (pdf)
Reliability block diagrams focus on components and connectors as do software architectures. However, some architectural styles possess characteristics which make traditional reliability block diagrams unusable as an analysis technique. In order to use the diagrams, they must be extended to reflect common architectural choices such as concurrency, distribution, dynamism, and implicit connectors.
USC-CSE-96-505 - Models for Composing Heterogeneous Software Architectures (Ahmed Abd-Allah, Barry Boehm)
Ahmed Abd-Allah, Barry Boehm, "Models for Composing Heterogeneous Software Architectures" (pdf)
A persistent problem in software engineering is the problem of software composition. The emergence of software architectures and architectural styles has focused attention on a new set of abstractions with which we can create and compose software systems. We examine the problem of providing a model for the composition of different architectural styles within software systems, i.e. the problem of composing heterogeneous architectures. We describe a model of pure styles that is based on a uniform representation. We provide a disciplined approach for analyzing some key aspects of architectural composition, and show the conditions under which systems will fail to be composed.
USC-CSE-95-503 - Reasoning about the Composition of Heterogeneous Architectures (Ahmed Abd-Allah, Barry Boehm)
Ahmed Abd-Allah, Barry Boehm, "Reasoning about the Composition of Heterogeneous Architectures," Qualifying Proposal (pdf)
A persistent problem in software engineering is how to put software systems together out of smaller subsystems: the problem of software composition. The emergence of software architectures and architectural styles has focused attention on a new set of abstractions with which we can create and compose software systems. We examine the problem of providing a model for the composition of different architectural styles within software systems, i.e. the problem of composing heterogeneous architectures. We describe a model of pure styles and of their composition. We provide a disciplined approach to the process of architectural composition, and techniques for using the approach to determine architectural constraints and the conditions under which systems will fail to be composed.
Ahmed Abd-Allah, "Composing Heterogeneous Software Architectures" (pdf)
A persistent problem in computer science is how to put software systems together out of smaller subsystems, the problem of software composition. The emergence of software architectures and architectural styles has introduced a higher level of abstraction at which we can create and compose software systems. We examine the problem of providing formal semantics to the composition of different architectural styles within software systems, i.e. the problem of composing heterogeneous architectures. We describe a theory of pure styles, and a theory of their composition. We show a disciplined approach to the process of architectural composition, and how to use the approach to bring out architectural constraints and under what conditions can styles be composed.
USC-CSE-95-500 - On the Definition of Software System Architecture (Cristina Gacek, Ahmed Abd-Allah, Bradford Clark, Barry Boehm)
Cristina Gacek, Ahmed Abd-Allah, Bradford Clark, Barry Boehm, "On the Definition of Software System Architecture," Proceedings, First International Workshop on Architectures for Software Systems, in Cooperation with the 17th International Conference on Software Engineering, D. Garlan (ed.), Seattle, WA, April 24-25, 1995, pp. 85-95 (pdf)
Although several definitions of "software architecture" have been presented, none of them to date enable a reviewer confronted with a complex of diagrams and symbols to determine whether it is an architecture for a system or not. We present a definition of "software system architecture" which provides a set of criteria for mak ing this determination. It is based on making the architectural rationale a first-class citizen in the definition, and on requiring the rationale to ensure that the architecture's components, connections, and constraints define a system that will satisfy a set of defined stakeholder needs for the system.
USC-CSE-94-499 - Focused Workshop on Software Architectures: Issue Paper (Cristina Gacek, Ahmed Abd-Allah, Bradford Clark, Barry Boehm)
Cristina Gacek, Ahmed Abd-Allah, Bradford Clark, Barry Boehm, "Focused Workshop on Software Architectures: Issue Paper," Knowledge Summary of the USC-CSE Focused Workshop on Software Reuse, Center for Software Engineering, University of Southern California, Los Angeles, CA, June 6-9, 1994 (pdf)
The Center for Software Engineering (CSE) at USC is currently involved in research on software architecting and architectures. The main objective of this workshop is to calibrate the CSE architecture research strategy to the Center Affiliates’ needs and priorities. This includes identifying and prioritizing the most critical architecture research issues; clarifying the nature of, and defining the interactions between the architecture subdisciplines (representation, style, domain specific software architectures, process, and infrastructure); and calibrating the maturity of emerging architecture infrastructure technologies with respect to Affiliate-scale needs.
This issue paper is the first step in the Focused Workshop process. It summarizes the CSE architecture research strategy elements and positions, and identifies candidate high-priority issues. The next steps in the process involve feedback from Affiliates on the strategy and issues via position papers and workshop discussions. We also plan to achieve the objectives of clarifying and calibrating the architecture state-of-the-art and state-of-the-practice via workshop presentations and discussions.
The strategies in the paper have already been influenced strongly by the USC-CSE Affiliates via the results of the February 1994 Executive Workshop on Information Architectures and Software Product Line Management.
Added June 24th, 2008
Ahmed Abd-Allah's PhD Dissertation - Composing Heterogeneous Software Architectures
A persistent problem in software engineering is how to put complex software systems together out of smaller subsystems, the problem of software composition. The emergence of software architectures and architectural styles has introduced a higher level of abstraction at which we can create and compose software systems. We examine the problem of providing formal semantics to the composition of different architectural styles within software systems, i.e. the problem of composing heterogeneous architectures. We describe a model of pure styles, and a model of their composition.
Our model of pure styles is highlighted by a uniform representation for describing many different styles. An architectural style space of major conceptual features is introduced which allows new styles to be rapidly incorporated into the model, including commercial-off-the-shelf packages which embody a specific style(s). We show a disciplined approach to the process of architectural composition, and show how architecture mismatches can be generated during composition. Finally, we describe a prototype tool which is built on top of the models.
August 1996
Marwan Abi-Antoun
USC-CSE-98-519 - Guidelines for the Life Cycle Objectives (LCO) and the Life Cycle Architecture (LCA) deliverables for Model-Based Architecting and Software Engineering (MBASE) (Barry Boehm, Dan Port, Marwan Abi-Antoun, Alexander Egyed)
Barry Boehm, Dan Port, Marwan Abi-Antoun, Alexander Egyed, "Guidelines for the Life Cycle Objectives (LCO) and the Life Cycle Architecture (LCA) deliverables for Model-Based Architecting and Software Engineering (MBASE)" (pdf)
Over our three years of developing digital library products for the USC Libraries, we have been evolving an approach called Model-Based (System) Architecting and Software Engineering (MBASE). MBASE involves early reconciliation of a project's success models, product models, process models, and property models. It extends the previous spiral model in two ways: initiating each spiral cycle with a stakeholder win-win stage to determine a mutually satisfactory (win-win) set of objectives, constraints, and alternatives for the system's next elaboration during the cycle; orienting the spiral cycles to synchronize with a set of life cycle anchor points: Life Cycle Objectives (LCO), Life Cycle Architecture (LCA), and Initial Operational Capability (IOC).
The MBASE guidelines present the content and the completion criteria for the LCO and LCA milestones (which correspond to the Inception and Elaboration Phases of the Rational Unified Process) of the following system definition elements: Operational Concept Description (OCD); System and Software Requirements Definition (SSRD); System and Software Architecture Description (SSAD); Life Cycle Plan (LCP); Feasibility Rationale Description (FRD); Risk-driven prototypes.
Added September 24th, 1998
USC-CSE-98-518 - Requirements Engineering, Expectations Management, and The Two Cultures (Barry Boehm, Marwan Abi-Antoun, Dan Port, Julie Kwan, Anne Lynch)
Barry Boehm, Marwan Abi-Antoun, Dan Port, Julie Kwan, Anne Lynch, "Requirements Engineering, Expectations Management, and The Two Cultures," Proceedings of the 4th IEEE International Symposium on Requirements Engineering, June 1999, pp. 14-22 (pdf)
In his seminal work, The Two Cultures, C.P. Snow found that science and technology policymaking was extremely difficult because it required the combined expertise of both scientists and politicians, whose two cultures had little understanding of each other's principles and practices [Snow, 1959].
During the last three years, we have conducted over 50 real-client requirements negotiations for digital library applications projects. Those largely involve professional librarians as clients and 5-6 person teams of computer science MS-degree students as developers. We have found that their two-cultures problem is one of the most difficult challenges to overcome in determining a feasible and mutually satisfactory set of requirements for these applications.
During the last year, we have been experimenting with expectations management and domain-specific lists of "simplifiers and complicators" as a way to address the two-cultures problem for software requirements within the overall digital library domain. Section 2 of this paper provides overall motivation and context for addressing the two-cultures problem and expectations management as significant opportunity areas in requirements engineering. Section 3 discusses the digital library domain and our stakeholder Win-Win and Model-Based (System) Architecting and Software Engineering (MBASE) approach as applied to digital library projects. Section 4 discusses our need for better expectations management in determining the requirements for the digital library projects are products over the first two years, and describes our approach in year 3 to address the two-cultures problem via expectations management. Section 5 summarizes results to date and future prospects.
Added September 24th, 1998
USC-CSE-98-510 - The MBASE Life Cycle Architecture Milestone Package: No Architecture Is An Island (Barry Boehm, Dan Port, Alexander Egyed, Marwan Abi-Antoun)
Barry Boehm, Dan Port, Alexander Egyed, Marwan Abi-Antoun, "The MBASE Life Cycle Architecture Milestone Package: No Architecture Is An Island," WICSA '99 (pdf)
This paper summarizes the primary criteria for evaluating software/system architectures in terms of key system stakeholders’ concerns. It describes the Model Based Architecting and Software Engineering (MBASE) approach for concurrent definition of a system’s architecture, requirements, operational concept, prototypes, and life cycle plans. It summarizes our experiences in using and refining the MBASE approach on 31 digital library projects. It concludes that a Feasibility Rationale demonstrating consistency and feasibility of the various specifications and plans is an essential part of the architecture’s definition, and presents the current MBASE annotated outline and guidelines for developing such a Feasibility Rationale.
Added August 17th, 1998
Chris Abts
USC-CSE-2003-520 - Composable Process Elements for Developing COTS-Based Applications (Barry Boehm, Dan Port, Ye Yang, Jesal Bhuta, Chris Abts)
Barry Boehm, Dan Port, Ye Yang, Jesal Bhuta, Chris Abts, "Composable Process Elements for Developing COTS-Based Applications," Proceedings, ISESE 2003, September/October 2003 (pdf)
Data collected from five years of developing e-service applications at USC-CSE reveals that an increasing fraction have been commercial-off-the-shelf (COTS)-Based Application (CBA) projects: from 28% in 1997 to 60% in 2001. Data from both small and large CBA projects show that CBA effort is primarily distributed among the three activities of COTS assessment, COTS tailoring, and glue code development and integration, with wide variations in their distribution across projects. We have developed a set of data-motivated composable process elements, in terms of these three activities, for developing CBA's as well an overall decision framework for applying the process elements. We present data regarding the movement towards CBA's and effort distribution among them; we then proceed to describe the decision framework and to present a real-world example showing how it operates within the WinWin Spiral process model generator to orchestrate, execute, and adapt the process elements to changing project circumstances.
Added June 24th, 2004
USC-CSE-2000-530 - Future Trends, Implications in Cost Estimation Models (Barry Boehm, Ellis Horowitz, Raymond Madachy, Chris Abts)
Barry Boehm, Ellis Horowitz, Raymond Madachy, Chris Abts, "Future Trends, Implications in Cost Estimation Models," CrossTalk, April 2000 (pdf)
The rapid pace of change in software technology requires everybody in the software business to continually rethink and update their practices just to stay relevant and effective. This article discusses this challenge first with respect to the USC COCOMO II software cost modeling project, and then for software-intensive organizations in general. It then presents a series of adaptive feedback loops by which organizations can use COCOMO II-type models to help cope with the challenges of change.
Added November 11th, 2005
USC-CSE-2000-510 - COTS Integration: Plug and Pray? (Barry Boehm, Chris Abts)
Barry Boehm, Chris Abts, "COTS Integration: Plug and Pray?" Computer, Volume 32, Number 1, January 1999, pp. 135-138 (pdf)
For most software applications, the use of commercial off-the-shelf products has become an economic necessity. Gone are the days when upsized industry and government information technology organizations had the luxury of trying to develop—and at greater expense, maintain— their own database, network, and user-interface management infrastructure. Viable COTS products are climbing up the protocol stack, from infrastructure into application solutions in such areas as office and management support, electronic commerce, finance, logistics, manufacturing, law, and medicine. For small and large commercial companies, time-to-market pressure also exert a strong pressure toward COTS-based solutions.
Added October 10th, 2000
USC-CSE-2000-505 - Software Development Cost Estimation Approaches - A Survey (Barry Boehm, Chris Abts, Sunita Chulani)
Barry Boehm, Chris Abts, Sunita Chulani, "Software Development Cost Estimation Approaches - A Survey," Qualifying Exam Report (Sunita Chulani) (pdf)
This paper summarizes several classes of software cost estimation models and techniques: parametric models, expertise-based techniques, learning-oriented techniques, dynamics-based models, regression-based models, and composite-Bayesian techniques for integrating expertise-based and regression-based models. Experience to date indicates that neural-net and dynamics-based techniques are less mature than the other classes of techniques, but that all classes of techniques are challenged by the rapid pace of change in software technology. The primary conclusion is that no single technique is best for all situations, and that a careful comparison of the results of several approaches is most likely to produce realistic estimates.
Added April 10th, 2000
USC-CSE-2000-503 - A Perspective on the Economic Life Span of COTS-based Software Systems: the COTS-LIMO Model (Chris Abts)
Chris Abts, "A Perspective on the Economic Life Span of COTS-based Software Systems: the COTS-LIMO Model," submitted to the Workshop on Continuing Collaborations for Successful COTS Development, ICSE 2000, Limerick, Ireland, June 4-5, 2000 (pdf)
The use of commercial-of-the-shelf (COTS) components is becoming ever more prevalent in the creation of large software systems. The rationale usually cited for this trend is that by using COTS components, immediate short-term gains in direct development effort & schedule are possible—admittedly, often as a trade-off for a more complicated long-term post-deployment maintenance environment. Even so, the conventional wisdom is that generally, the more of the system that can be built using COTS components, the better. Anecdotal evidence recently gathered while conducting data collection interviews for the COCOTS COTS integration cost model suggests, however, that there may be diminishing returns in trying to maximize the use of COTS components in a system development. Beyond a certain point, an increase in the number of COTS components in a system may actually reduce the system's overall economic life span rather than increase it. This paper discusses why this may be true, at least in some cases, and proposes a new economic COTS life span model, COTS-LIMO, as a way of possibly examining these effects. As of this writing, the suggestion being made here that increasing the number of COTS components in a system ultimately produces diminishing returns can only be called a hypothesis. But if proven true, even in some cases, then this could have significant implications for current policy decisions being made by governments and organizations encouraging an ever expanding use of COTS components in software system developments.
Added March 8th, 2000
USC-CSE-2000-502 - Empirical Observations on COTS Software Integration Effort Based on the Initial COCOTS Calibration Database (Chris Abts, Barry Boehm, Elizabeth Bailey Clark)
Chris Abts, Barry Boehm, Elizabeth Bailey Clark, "Empirical Observations on COTS Software Integration Effort Based on the Initial COCOTS Calibration Database," Proceedings of the Twenty-Fifth Annual Software Engineering Workshop (SEW 25), NASA/Goddard Space Flight Center, 2000 (pdf)
As the use of commercial-of-the-shelf (COTS) components becomes ever more prevalent in the creation of large software systems, the need for the ability to reasonably predict the true lifetime cost of using such software components grows accordingly. This paper presents empirically-based findings about the effort associated with activities found to be significant in the development of systems using COTS components. The findings are based upon data collected for the purpose of calibrating the COCOTS COTS software integration cost model, an extension to the COCOMO II cost model designed to capture costs COCOMO does not. A brief overview of COCOTS is presented to put the data in perspective, including its relation to COCOMO II. A set of histograms is then shown summarizing the effort data collected to date. The paper concludes with some observations suggested by an examination of that calibration data.
Added March 8th, 2000
USC-CSE-2000-501 - COCOTS: A COTS Software Integration Lifecycle Cost Model - Model Overview and Preliminary Data Collection Findings (Chris Abts, Barry Boehm, Elizabeth Bailey Clark)
Chris Abts, Barry Boehm, Elizabeth Bailey Clark, "COCOTS: A COTS Software Integration Lifecycle Cost Model - Model Overview and Preliminary Data Collection Findings," Proceedings ESCOM-SCOPE 2000 Conference, Munich, Germany, April 18-20, 2000, pp. 325-333 (pdf)
As the use of commercial-of-the-shelf (COTS) components becomes ever more prevalent in the creation of large software systems, the need for the ability to reasonably predict the true lifetime cost of using such software components grows accordingly. In using COTS components, immediate short-term gains in direct development effort & schedule are possible, but usually as a trade-off for a more complicated long-term post-deployment maintenance environment. In addition, there are risks associated with COTS software separate from those of creating components from scratch. These unique risks can further complicate the development and post-deployment situations. This paper discusses a model being developed as an extension of the COCOMO II cost model. COCOTS attempts to predict the lifecycle costs of using COTS components by capturing the more significant COTS risks in its modeling parameters. The current state of the model is presented, along with some preliminary findings suggested by an analysis of calibration data collected to date. The paper concludes with a discussion of the on-going effort to further refine the accuracy and scope of COCOTS.
Added March 8th, 2000
USC-CSE-2000-500 - USC COCOMO II.2000 (Barry Boehm, Chris Abts, Jongmoon Baik, A. Winsor Brown, Sunita Chulani, Bradford Clark, Ellis Horowitz, Ray Madachy, Donald J. Reifer, Bert Steece)
Barry Boehm, Chris Abts, Jongmoon Baik, A. Winsor Brown, Sunita Chulani, Bradford Clark, Ellis Horowitz, Ray Madachy, Don Reifer, Bert Steece, "USC COCOMO II.2000" (pdf)
This manual presents two models, the Post-Architecture and Early Design models. These two models are used in the development of Application Generator, System Integration, or Infrastructure developments [Boehm et al. 2000]. The Post-Architecture is a detailed model that is used once the project is ready to develop and sustain a fielded system. The system should have a life-cycle architecture package, which provides detailed information on cost driver inputs, and enables more accurate cost estimates. The Early Design model is a high-level model that is used to explore of architectural alternatives or incremental development strategies. This level of detail is consistent with the general level of information available and the general level of estimation accuracy needed.
The Post-Architecture and Early Design models use the same approach for product sizing (including reuse) and for scale factors. These will be presented first. Then, the Post-Architecture model will be explained followed by the Early Design model.
Added September 8th, 2008
USC-CSE-98-520 - COTS Software Integration Cost Modeling Study (Chris Abts, Barry Boehm)
Chris Abts, Barry Boehm, "COTS Software Integration Cost Modeling Study," final report under DoD contract F30602-94-C-1095 (pdf)
This study represents a first effort towards the goal of developing a comprehensive COTS integration cost modeling tool. The approach taken was to first examine a wide variety of sources in an attempt to identify the most significant factors driving COTS integration costs, and to develop a mathematical form for such a model. These sources ranged from already existing cost models to information gathered in a preliminary high level data collection survey. Once the form and candidate drivers had been identified, the next step was to gather project level COTS integration effort data in a second round data collection exercise. This project level data was then used to calibrate and validate the proposed model. Data from both a graduate level software engineering class and from industrial sources were used in calibration attempts. The industrial data proved problematic, however, so for the purposes of this study, the final calibration of the model was based upon the student projects.
The final result was a cost model following the general form of the well-known COCOMO software cost estimation model, but with an alternate set of cost drivers. The scope of the model is also narrow, addressing only initial integration coding costs. The predictive power of the model at this stage is only fair, but it was demonstrated that with appropriate data, the accuracy of the model could be greatly improved.
Finally, the richness to the problem of capturing all significant costs associated with using COTS software offers many worth-while directions in which to expand the scope of this model.
Added September 24th, 1998
Chris Abts' Dissertation - Extending the COCOMO II Software Cost Model to Estimate Effort and Schedule for Software Systems Using Commercial-off-the-Shelf (COTS) Software Components: The COCOTS Model
Chris Abts , "Extending the COCOMO II Software Cost Model to Estimate Effort and Schedule for Software Systems Using Commercial-off-the-Shelf (COTS) Software Components: The COCOTS Model," PhD Dissertation, Department of Industrial and Systems Engineering, University of Southern California, May 2004 (pdf)
This dissertation discusses changes in software development practice that have occurred since the 1970s. In particular, the focus is on the rise of the "off-the-shelf"approach whereby large software systems are constructed out of a mix of original code and adapted code as well as pre-existing "black box" components for which the developer has no access to the source code. While certainly used prior to 1980, this technique of using black box elements has taken on greatly increased importance in recent years as one way to manage development risks as the overall complexity of software has grown.
Software estimation models, however, have generally not kept apace with off-the-shelf techniques. This includes the widely-used COCOMO software estimation model. While recently updated as the COCOMO II estimation model to reflect other changes in software development since its original publication in 1981, it still is unable to accommodate the use of black box off-the-shelf components in its estimation framework.
The focus of this dissertation then is the investigation of a potential extension of COCOMO II that is intended to provide an estimation capability for any off-the-shelf elements being designed into a software system. It begins with an exploration of how development activities differ when using off-the-shelf components as opposed to developing system components as original code. This serves as a basis for the formulation of an off the-shelf estimation model called COCOTS that is carried through several iterations, each intended to improve upon its predecessor. The dissertation concludes with a comparison of the fidelity of COCOTS with COCOMO II, limitations of available project data that impacted the calibration of COCOTS, and suggestions for further investigation that might improve the fidelity of COCOTS itself and also expand and deepen the general understanding of the benefits and risks of using off-the-shelf components in software system development.
Mohammed Al-Said
USC-CSE-2001-500 - Avoiding the Software Model-Clash Spiderweb (Barry Boehm, Dan Port, Mohammed Al-Said)
Barry Boehm, Dan Port, Mohammed Al-Said, "Avoiding the Software Model-Clash Spiderweb," Computer, Volume 33, Issue 11, November 2000, pp. 120-122 (pdf)
Analysts frequently describe troubled projects with the tarpit metaphor used o effectively in Fred Brooks’s The Mythical Man-Month (2nd ed., Addison-Wesley, Reading, Mass., 1995). We have found a similarly effective metaphor: Think of a troubled software project as an insect caught in a spiderweb of sticky constraints, trying desperately to break free before the spider arrives to feed.
Added May 15th, 2001
Mohammed Al-Said's PhD Dissertation - Detecting Model Clashes During Software Systems Development
Mohammed Al-Said, "Detecting Model Clashes During Software Systems Development," PhD Dissertation, Department of Computer Science, University of Southern California, December 2003 (pdf)
Software models are widely used during software systems development. Software developers use the models to better understand the system users' requirements, develop candidate solutions, and validate their decisions. Currently, the set of existing software models is large. Model clashes occur when models with inconsistent assumptions are used at the same time during the development of a software dependent system. Model clashes occur frequently, impede product development, and may cause project failure if not detected and avoided in a timely manner. But outsides of product model clashes (architecture, structure, traceability gaps), relatively little has been done to address them.
This thesis lays out the background of the model clashes problem which includes formally defining a model-clash, formally demonstrating that model clashes exist between software models, and listing the causes of model clashes. It describes a new method for identifying the models' assumptions and the clashes among these assumptions. This method was validated by applying it against a mixture of commonly used software models and the result was used to assess the ability of MBASE (Model Based system Architecting and Software Engineering) to identify and avoid model clashes. A semi-automated software tool was developed based on this method.
To demonstrate the value of detecting and avoiding model clashes, this thesis establishes the relationship between the consequences of model clashes and the risk in software projects. Using data from 35 completed software projects, it shows that each clash has an impact, which can be defined as the product of the clash's occurrence probability and severity. This thesis shows that the clash impact is directly related to the project risk exposure.
Finally, this thesis describes an experiment involving 18 software projects, where a process was applied to detect, analyze, resolve, and avoid model clashes. The results demonstrate the distribution of the different clash types and each type contribution to the project risk. The results also validate the hypothesis: detecting and avoiding model clashes during software systems development improves the software projects' outcome.
Gan Wang, Ricardo Valerdi, Aaron Ankrum, Cort Millar, Garry J. Roedler, "COSYSMO Reuse Extension," INCOSE 2008 (pdf)
Reuse in systems engineering is a frequent, but poorly understood phenomenon. Nevertheless, it has a significant impact on estimating the appropriate amount of systems engineering effort with models like the Constructive Systems Engineering Cost Model. Practical experience showed that the initial version of COSYSMO, a model based on a “build from the scratch” philosophy, needed to be refined in order to incorporate reuse considerations that fit today’s industry environment. The notion of reuse recognizes the effect of legacy system definition in engineering a system and introduces multiple reuse categories for classifying each of the four COSYSMO size drivers – requirements, interfaces, algorithms, and operational scenarios. It fundamentally modifies the counting rules for the COSYSMO size drivers and updates the definition of system size in COSYSMO.
In this paper, we present (1) the definition of the COSYSMO reuse extension and the approach employed to define this extension; (2) the updated COSYSMO size driver definitions that are consistent with the reuse model; (3) the method applied to defining the reuse weights used in the modified parametric relationship; (4) a practical implementation example that instantiates the reuse model by an industry organization and the empirical data that provided practical validation of the extended COSYSMO model; and (5) recommendations for organizational implementation and deployment of this extension.
Added May 12th, 2008
USC-CSSE-2007-726 - Architecture-Based Drivers for System-of-Systems and Family-of-Systems Cost Estimating (Gan Wang, Philip Wardle, Aaron Ankrum)
Gan Wang, Philip Wardle, Aaron Ankrum, "Architecture-Based Drivers for System-of-Systems and Family-of-Systems Cost Estimating," INCOSE 2006 (pdf)
As the industry undergoes a paradigm shift from a system-based procurement model to a capability-based acquisition model with a focus on integration of legacy systems and interoperability of systems of systems and families of systems, new challenges have emerged for the field of cost estimating. What is the cost of an operational capability in a net centric environment based on enterprise architecture? This paper explores a set of enterprise architecture-based drivers for estimating the life cycle cost or total ownership cost of operational capabilities from integration of complex systems of systems and families of systems. It attempts to extend the traditional systems engineering practices and to address the new challenges from capability-based engineering and interoperability of systems of systems.
Added May 12th, 2008
Farhad Arbab
USC-CSE-2003-509 - Effective Modeling of Software Architectural Assemblies Using Constraint Automata (Nikunj R. Mehta, Marjan Sirjani, Farhad Arbab)
Nikunj R. Mehta, Marjan Sirjani, Farhad Arbab, "Effective Modeling of Software Architectural Assemblies Using Constraint Automata," SEN-R0309, CWI, Amsterdam, October 2003 (pdf)
Alfa is a framework for the construction of software architectures and their elements from architectural primitives. In any system involving events from multiple sources, synchrony and asynchrony between events arise naturally. Support for simultaneous synchrony and asynchrony, and scalability to assemblies of large numbers of architectural primitives are central concerns for effectively modeling software architectural assemblies in Alfa. An increasingly popular formalism for event-based modeling of the behavior of software architectures, labeled transition systems (LTS), was initially chosen to model the behavior of Alfa assemblies. However, this creates an impedance mismatch with the architect’s mental model and lacks sufficient scalability. We therefore propose a formal approach to effectively model software architectural assemblies that addresses these limitations, using constraint automata. Constraint automata can be mapped to LTS thus utilizing existing techniques for analysis of behavioral properties. We evaluate the effectiveness of our approach using two application architectures assembled from Alfa’s primitives.
Added September 25th, 2003
Elliot Axelband
USC-CSSE-2008-809 - A Research Agenda for Systems of Systems Architecting (Ricardo Valerdi, Elliot Axelband, Thomas Baehren, Barry Boehm, Dave Dorenbos, Scott Jackson, Azad Madni, Gerald Nadler, Paul Robitaille, Stan Settles)
Ricardo Valerdi, Elliot Axelband, Thomas Baehren, Barry Boehm, Dave Dorenbos, Scott Jackson, Azad Madni, Gerald Nadler, Paul Robitaille, Stan Settles, "A Research Agenda for Systems of Systems Architecting," International Journal of System of Systems Engineering, 2008 (pdf)
This paper, documents the activity of a workshop on defining a research agenda for Systems of Systems SoS; Architecting, which was held at USC in October 2006. After two days of invited talks on critical success factors for SoS engineering, the authors of this paper convened for one day to brainstorm topics for the purpose of shaping the near-term research agenda of the newly convened USC Center for Systems and Software Engineering (CSSE). The output from the workshop is a list of ten high-impact items with corresponding research challenges in the context of SoS Architecting. Each item includes a description of the research challenges, its link to contemporary academic or industrial problems and reasons for advocacy of that area. The items were assessed in terms of value and difficulty to determine a prioritisation both for the CSSE's future research agenda and for others in the field.
Added April 21st, 2008
Pongtip Aroonvatanaporn
USC-CSSE-2008-832 - Incremental Commitment Model Process Guidelines for Software Engineering Class (Supannika Koolmanojwong, Pongtip Aroonvatanaporn, Itti Charoenthongtrakul)
Supannika Koolmanojwong, Pongtip Aroonvatanaporn, Itti Charoenthongtrakul, "Incremental Commitment Model Process Guidelines for Software Engineering Class" (pdf)
Effectively communicating the software process model to the software engineers is essential in enabling them to understand the overall process as well as specific areas of focus. To satisfy the objective of helping students learn the software processes, an Electronic Process Guide (EPG) for the Incremental Commitment Model (ICM) has been developed by the University of Southern California (USC) Center for System and Software Engineering (CSSE) and has been experimented for its efficiency and effectiveness by software engineering students. This paper reports on the experimental results of utilizing the EPG of the ICM process to develop software systems comparing with the use of traditional paper-based guidelines in the past. The analyses focus on both quantitative and qualitative aspects of the software development process based on the objectives defined by Humphrey and Kellner [8], process model characteristics defined by Fuggetta [1], people-oriented process information aspects by Heidrich, et al. [6], and students’ performances and feedbacks.
Added January 28th, 2009
Thomas Baehren
USC-CSSE-2008-809 - A Research Agenda for Systems of Systems Architecting (Ricardo Valerdi, Elliot Axelband, Thomas Baehren, Barry Boehm, Dave Dorenbos, Scott Jackson, Azad Madni, Gerald Nadler, Paul Robitaille, Stan Settles)
Ricardo Valerdi, Elliot Axelband, Thomas Baehren, Barry Boehm, Dave Dorenbos, Scott Jackson, Azad Madni, Gerald Nadler, Paul Robitaille, Stan Settles, "A Research Agenda for Systems of Systems Architecting," International Journal of System of Systems Engineering, 2008 (pdf)
This paper, documents the activity of a workshop on defining a research agenda for Systems of Systems SoS; Architecting, which was held at USC in October 2006. After two days of invited talks on critical success factors for SoS engineering, the authors of this paper convened for one day to brainstorm topics for the purpose of shaping the near-term research agenda of the newly convened USC Center for Systems and Software Engineering (CSSE). The output from the workshop is a list of ten high-impact items with corresponding research challenges in the context of SoS Architecting. Each item includes a description of the research challenges, its link to contemporary academic or industrial problems and reasons for advocacy of that area. The items were assessed in terms of value and difficulty to determine a prioritisation both for the CSSE's future research agenda and for others in the field.
Added April 21st, 2008
Jongmoon Baik
USC-CSSE-2007-721 - A Quality-Based Cost Estimation Model for the Product Line Life Cycle (Hoh Peter In, Jongmoon Baik, Sangsoo Kim, Ye Yang, Barry Boehm)
Hoh Peter In, Jongmoon Baik, Sangsoo Kim, Ye Yang, Barry Boehm, "A Quality-Based Cost Estimation Model for the Product Line Life Cycle," Communications of The ACM, Volume 49, Number 12, December 2006 (pdf)
In reusing common organizational assets, the software product line (SPL) provides substantial business opportunities for reducing the unit cost of similar products, improving productivity, reducing time to market, and promoting customer satisfaction [4]. By adopting effective product line practices, return on investment (ROI) becomes increasingly critical in the decision-making process. The majority of SPL cost estimation
and ROI models [5-9] confine themselves to software development costs and savings. However, if software quality cost is considered in the spectrum of the SPL life cycle, product lines can result in considerably larger payoffs, compared to non-product lines.
This article proposes a quality-based product line life cycle cost estimation model, called qCOPLIMO, and investigates the effect of software quality cost on the ROI of SPL. qCOPLIMO is derived from two COCOMO suite models: COPLIMO and COQUALMO, as presented in Figure 1. COPLIMO [2] provides a baseline cost estimation model of the product line life cycle, and COQUALMO [3] estimates the number of residual defects. These models are used to estimate software quality cost. Both models are an extension of COCOMO II [1].
Added November 8th, 2007
USC-CSE-2002-514 - Disaggregating and Calibrating the CASE Tool Variable in COCOMO II (Barry Boehm, Bert Steece, Jongmoon Baik)
Barry Boehm, Bert Steece, Jongmoon Baik, "Disaggregating and Calibrating the CASE Tool Variable in COCOMO II," IEEE Transactions on Software Engineering, Volume 28, Issue 11, November 2002, pp. 1009-1022 (pdf)
Software systems of today are frequently composed from prefabricated, heterogeneous components that provide complex functionality and engage in complex interactions. Software architecture research has revealed the importance of component interactions on our ability to perform software composition. Various development organizations have found interaction mismatches to be both difficult and a core issue behind failed software integration efforts. This paper is aimed at improving the understanding of component interactions, embodied in the notion of software connectors, in order to prevent such failures. Our previous work has resulted in a four-level classification framework for studying the characteristics of connectors. This paper presents a comprehensive taxonomy of software connectors based on the previously published connector classification framework. This taxonomy is used to explain various existing software connectors and study compatibility of connector characteristics, intended to prevent component interaction mismatches.
Added June 24th, 2004
USC-CSE-2000-504 - Empirical Analysis of CASE Tool Effects on Software Development Effort (Jongmoon Baik, Barry Boehm)
During the last couple of decades, CASE (Computer Aided Software Engineering) tools have played a critical role in improvement of software productivity and quality by assisting tasks in software development processes. Many initiatives in the field were pursued in the 1980’s and 1990’s to provide more effective CASE technologies and development environments. Even though the CASE field is no longer active research area, most software development teams use a huge range of CASE tools that are typically assembled over some period with the hope of productivity and quality improvements throughout the software development process. The variety and proliferation of tools in the current CASE market makes it difficult to understand what kinds of tasks are supported and how much effort can be reduced by using CASE tools. In this paper, we provide a classification of CASE tools by activity coverage in a software development lifecycle. We also report a experimental result of Bayesian analysis on CASE tool effects with a extended set of tool rating scales from COCOMO (COnstructive COst MOdel) II with which CASE tools are effectively evaluated.
Added March 20th, 2000
USC-CSE-2000-500 - USC COCOMO II.2000 (Barry Boehm, Chris Abts, Jongmoon Baik, A. Winsor Brown, Sunita Chulani, Bradford Clark, Ellis Horowitz, Ray Madachy, Donald J. Reifer, Bert Steece)
Barry Boehm, Chris Abts, Jongmoon Baik, A. Winsor Brown, Sunita Chulani, Bradford Clark, Ellis Horowitz, Ray Madachy, Don Reifer, Bert Steece, "USC COCOMO II.2000" (pdf)
This manual presents two models, the Post-Architecture and Early Design models. These two models are used in the development of Application Generator, System Integration, or Infrastructure developments [Boehm et al. 2000]. The Post-Architecture is a detailed model that is used once the project is ready to develop and sustain a fielded system. The system should have a life-cycle architecture package, which provides detailed information on cost driver inputs, and enables more accurate cost estimates. The Early Design model is a high-level model that is used to explore of architectural alternatives or incremental development strategies. This level of detail is consistent with the general level of information available and the general level of estimation accuracy needed.
The Post-Architecture and Early Design models use the same approach for product sizing (including reuse) and for scale factors. These will be presented first. Then, the Post-Architecture model will be explained followed by the Early Design model.
Added September 8th, 2008
USC-CSE-99-528 - The Effects of CASE Tools on Software Development Effort (Jongmoon Baik)
Jongmoon Baik, "The Effects of CASE Tools on Software Development Effort," Qualifying Report for partial fullfillment of Computer Science Department requirements (pdf)
It is common knowledge that software tools have played a critical role in the software engineering process by improving software quality and productivity. A huge number of CASE (Computer Aided Software Engineering) tools have been produced to assist tasks in a software development process since the end of 1970's. Many studies in the CASE field were done in the 1980's and the early 1990's to provide more effective CASE technologies and environments. While the research in this field is no longer as active, software developers use a range of CASE tools that are typically assembled over the period to support tasks throughout the software process. The diversity and proliferation of software tools in the current CASE market makes it difficult to understand what kind of tasks are supported and how much effort can be reduced by using software tools in a software development process. A big challenge is to alleviate this difficulties in the software engineering community. The primary goals of this research are to establish a framework for classifying software tools according to their support in a software lifecycle, to provide tool rating scales with which software tools are effectively evaluated, and to analyze the effect of software tools on the software development effort.
Added November 9th, 1999
USC-CSE-99-524 - Software Effort and Schedule Estimation Using The Constructive Cost Model: COCOMO II (Jongmoon Baik, Sunita Chulani, Ellis Horowitz)
Software Effort and Schedule Estimation Using The Constructive Cost Model: COCOMO II (pdf)
Jongmoon Baik, Sunita Chulani, Ellis Horowitz
During development of a software product, several questions arise: How long will it take to develop? How much will it cost? How many people will be needed?
In answering these questions, several others arise: What are the risks involved if we compress the schedule by a certain fraction? Can we invest more in strategies such as tools, reuse, and process maturity and get higher productivity, quality and shorter cycle times? How can the cost and schedule be broken down by component, stage and activity?
COCOMO II facilitates the planning process by enabling one to answer the above questions using a parametric model that has been calibrated to actual completed software projects collected from Commercial, Aerospace, Government and non-profit organizations. Although, COCOMO II consists of three submodels, Applications Composition, Early Design, and Post-architecture, each one offering increased fidelity the further along one is in the project planning and design process; only the Early Design and Post Architecture models have been calibrated and implemented in the software.
Submitted for ICSE 99 Informal Demo
Added July 14th, 1999
Jongmoon Baik's PhD Dissertation - The Effects of CASE Tools on Software Development Effort
The Effects of CASE Tools on Software Development Effort (pdf)
Jongmoon Baik
CASE (Computer Aided Software Engineering) tools have played a critical role in improving software productivity and quality by assisting tasks in software development processes since the 1970’s. Several parametric software cost models adopt “use of software tools” as one of the environmental factors that affect software development productivity. However, most software development teams use CASE tools that are assembled over time and adopt new tools without establishing formal evaluation criteria. Several software cost models assess the productivity impacts of CASE tools based just on breadth of tool coverage without considering other productivity dimensions such as degree of integration, tool maturity, and user support. This dissertation provides an extended set of tool rating scales based on the completeness of tool coverage, the degree of tool integration, and tool maturity/user support. It uses these scales to refine the way in which CASE tools are effectively evaluated within COCOMO (COnstructive COst MOdel) II. In order to find a best fit of weighting values for the extended set of tool rating scales in the extended research model, a Bayesian approach is adopted to combine two sources of (expert-judged and data-determined) information to increase prediction accuracy. The research model using the extended three TOOL rating scales is validated by using cross-validation methodologies such as data splitting and bootstrapping.
December 2000
Daniel Baker
USC-CSSE-2008-833 - Accurate Estimates without Calibration? (Tim Menzies, Oussama Elrawas, Barry Boehm, Raymond Madachy, Jairus Hihn, Daniel Baker, Karen Lum)
Tim Menzies, Oussama Elrawas, Barry Boehm, Raymond Madachy, Jairus Hihn, Daniel Baker, Karen Lum, "Accurate Estimates without Calibration?" Lecture Notes in Computer Science, Making Globally Distributed Software Development a Success Story, Volume 5007, 2008, Springer Belin / Heidelberg, pp. 210-221 (pdf)
Most process models calibrate their internal settings using historical data. Collecting this data is expensive, tedious, and often an incomplete process.
Is it possible to make accurate software process estimates without historical data? Suppose much of uncertainty in a model comes from a small subset of the model variables. If so, then after (a) ranking variables by their ability to constrain the output; and (b) applying a small number of the top-ranked variables; then it should be possible to (c) make stable predictions in the constrained space.
To test that hypothesis, we combined a simulated annealer (to generate random solutions) with a variable ranker. The results where quite dramatic: in one of the studies in this paper, we found process options that reduced the median and variance of the effort estimates by a factor of 20. In ten case studies, we show that the estimates generated in this manner are usually similar to those produced by standard local calibration.
Our conclusion is that while it is always preferable to tune models to local data, it is possible to learn process control options without that data.
Added January 29th, 2009
Deborah A. Baker
USC-CSE-87-501 - Next Generation Software Environment: Principles, Problems, and Research (Richard N. Taylor, Deborah A. Baker, Frank C. Belz, Barry Boehm, Lori A. Clarke, David A. Fischer, Leon J. Osterweil, Richard Selby, Jack C. Wileden, Alexander L. Wolf, Michal Young)
Richard N. Taylor, Deborah A. Baker, Frank C. Belz, Barry Boehm, Lori A. Clarke, David A. Fischer, Leon J. Osterweil, Richard Selby, Jack C. Wileden, Alexander L. Wolf, Michal Young, "Next Generation Software Environment: Principles, Problems, and Research," Dep. Inform. Comput. Sci., Univ. Calif., Irvine, CA, Tech. Rep. 87-16, July 1987, also issued as Arcadia Doc. UCI-87-10, Univ. Colorado Tech. Rep. CU-CS-370- 87, Univ. Mass., Amherst, Tech. Rep. 87-63, and Incremental Systems Corp. Tech. Rep. 87-7-1 (pdf)
The past decade has seen a burgeoning of research and development in software environments. Conferences have been devoted to the topic of practical environments, journal papers produced, and commercial systems sold. Given all the activity, one might expect a great deal of consensus on issues, approaches, and techniques. This is not the case, however. Indeed, the term "environment" is still used in a variety of conflicting ways. Nevertheless substantial progress has been made and we are at least nearing consensus on many critical issues.
The purpose of this paper is to characterize environments, describe several important principles that have emerged in the last decade or so, note current open problems, and describe some approaches to these problems, with particular emphasis on the activities of one large-scale research program, the Arcadia project. Consideration is also given to two related topics: empirical evaluation and technology transition. That is, how can environments and their constituents be evaluated, and how can new developments be moved effectively into the production sector?
Added June 18th, 2008
Bob Balzer
USC-CSE-93-500 - Domain Specific Software Architectures-Command and Control (Christine Braun, William Hatch, Theodore Ruegsegger, Bob Balzer, Martin S. Feather, Neil Goldman, Dave Wile)
Christine Braun, William Hatch, Theodore Ruegsegger, Bob Balzer, Martin Feather, Neil Goldman, Dave Wile, "Domain Specific Software Architectures-Command and Control," 1992 IEEE Symposium on Computer-Aided Control System Design (CACSD), Napa, CA, March 17-19, 1992, pp. 129-136 (pdf)
GTE is the Command and Control contractor for the Domain Specific Software Architectures program. The objective of this program is to develop and demonstrate an architecture-driven, component-based capability for the automated generation of command and control (C2) applications. Such a capability will significantly reduce the cost of C2 application development and will lead to improved system quality and reliability through the use of proven architectures and components.
A major focus of GTE's approach is the automated generation of application components in particular subdomains. Our initial work in this area has concentrated in the message handling subdomain; we have defined and prototyped an approach that can automate one of the most software-intensive parts of C2 systems development.
This paper provides an overview of the GTE team's DSSA approach and then presents our work on automated support for message processing.
Added June 25th, 2008
Jae young Bang
USC-CSSE-2009-510 - Online Reliability Improvement via Smart Redundancy in Systems with Faulty and Untrusted Participants (Yuriy Brun, George Edwards, Jae young Bang, Nenad Medvidovic)
Yuriy Brun, George Edwards, Jae young Bang, Nenad Medvidovic, "Online Reliability Improvement via Smart Redundancy in Systems with Faulty and Untrusted Participants" (pdf)
Many software systems today, such as computational grids, include faulty and untrusted components. As faults are inevitable, these systems utilize redundancy to achieve fault tolerance. In this paper, we present two new, "smart" redundancy techniques: iterative redundancy and progressive redundancy. The two techniques are efficient, adaptive, and automated. They are efficient in that they leverage runtime information to improve system reliability using fewer resources than existing methods. They are automated in that they inject redundancy in situations where it is most beneficial and eliminate it where it is unnecessary. Finally, they are adaptive in that they increase redundancy on-the-fly when component reliability drops and decrease redundancy when component reliability improves. We enumerate examples of systems that can benefit from our techniques but focus in this paper on computational grid systems. We present formal analytical and empirical analyses, demonstrating our techniques on a real-world computational grid and comparing them to existing methods.
Added May 13th, 2009
Yimin Bao
Yimin Bao's PhD Dissertation - A Flexible Integration Framework for Software Tool Interoperability
Yimin Bao, "A Flexible Integration Framework for Software Tool Interoperability," PhD Dissertation, Department of Computer Science, University of Southern California, August 1996 (pdf)
Current trend of constructing new systems from collections of pre-existing third-party tools and commercial off-the-shelf (COTS) software presents serious challenges to existing integration technology. The unique constraints of third-party software, the interactive, autonomous nature of most of today's software applications, and the increasingly emphasized new integration requirements are among the major reasons for causing this difficulty.
This dissertation presents a flexible integration framework which has general applicability for pre-existing tools and COTS software, supports users to easily change the way software interact with each other (thus supporting flexible integration, system evolution and component reusability), and is easily programmable by the end-users. The framework consists of four major substrates: (1) A dynamic interoperability model which separates interaction relationship from tools and provides implicit communication and dynamic binding for managing independence and flexibility of the interaction relationship. This forms the conceptual base for our framework; (2) A black box integration approach called implicit tool encapsulation which extends the traditional integration interfaces to graphical user interface and system interface, and uses passive, implicit, system-centered mechanism for tool encapsulation; (3) A general methodology for tool integration which is derived from the dynamic interoperability model and implicit tool encapsulation approach, and is applicable for pre-existing third-party tool and COTS software; (4) A language called Tool Integration Language (TIL) which has the capability of accessing the functionality of tools through their user interface as well as other interfaces, and it can be used to describe the user's interaction between tools and the interaction between tools themselves. This provides necessary integration language for our framework and de-couples the integration policy from the mechanism.
A prototype system--Tool Integration Server System (TISS) has been constructed which supports TIL glue code generation and execution, and provides flexible integration mechanisms for our framework. By instantiating the general integration methodology with TIL language and TISS system, it generates a flexible and practical integration approach for integrating pre-existing, GUI-based, interactive tools without any source code modification.
Victor R. Basili
USC-CSE-2004-516 - COTS-Based Systems - Twelve Lessons Learned about Maintenance (Donald J. Reifer, Victor R. Basili, Barry Boehm, Betsy Clark)
Donald J. Reifer, Victor R. Basili, Barry Boehm, Betsy Clark, "COTS-Based Systems - Twelve Lessons Learned about Maintenance," ICCBSS 2004 (pdf)
This paper presents the twelve most significant lessons the CeBASE community has learned across a wide variety of projects, domains, and organizations about COTS-Based Systems (CBS) maintenance. Because many of the lessons identified are not intuitive, the source and implications of the lesson are discussed as well within the context of maintenance model for CBS.
Added November 14th, 2005
USC-CSE-2004-515 - Spiral Acquisition of Software-Intensive Systems of Systems (Barry Boehm, A. Winsor Brown, Victor R. Basili, Rich Turner)
Barry Boehm, A. Winsor Brown, Victor R. Basili, Rich Turner, "Spiral Acquisition of Software-Intensive Systems of Systems," CrossTalk, May 2004 (pdf)
The Department of Defense and other organizations are finding that the acquisition and evolution of complex systems of systems is both software-intensive and fraught with old and new sources of risk. This article summarizes both old and new sources of risk encountered in acquiring and developing complex software-intensive systems of systems. It shows how these risks can be addressed via risk analysis, risk management planning and control, and application of the risk-driven Win-Win Spiral Model. It will also discuss techniques for handling complicating factors such as compound risks, incremental development, and rapid change, and illustrates the use of principles and practices with experience in applying the model to the U.S. Army Future Combat Systems program and similar programs.
Added November 14th, 2005
USC-CSE-2002-503 - Realizing the Benefits of the CMMI with the CeBASE Method (Barry Boehm, Dan Port, Victor Basili)
Barry Boehm, Dan Port, Victor Basili, "Realizing the Benefits of the CMMI with the CeBASE Method" (pdf)
Future systems will be increasingly software-intensive, but the type of software development they will need is not well covered by current development and maturity models such as the waterfall model and Software Capability Maturity Model development of software-intensive systems will need situation-specific balancing of discipline and flexibility to address such issues as COTS, open source, distribution, mobility rapid change, agents, collaboration support, and simultaneous achievement of rapid development and high dependability. This paper shows how the CMMI's integration of modern systems engineering, software engineering, and integrated process and product development concepts provides a framework for redressing the shortfalls of the Software CMM, and for enabling projects and organizations to achieve the right balance of discipline and flexibility for their particular situations. But the CMMI has shortfalls of its own. It provides little guidance on how to define and execute specific processes for a specific project or organization. The paper summarizes various process model generators for software intensive systems such as the spiral, the Rational Unified Process (RUP), MBASE, and the CeBASE Method. It concludes that the CeBASE Method best covers the full range of concerns in the CMMI, resolves its practice-focus shortfalls, and covers additional best practices not in the CMMI, such as business case analysis, requirements prioritization, and evolution requirements.
Added May 23rd, 2002
USC-CSE-2002-502 - Achieving CMMI Level 5 Improvements with MBASE and the CeBASE Method (Barry Boehm, Dan Port, Victor Basili, Apurva Jain)
Barry Boehm, Dan Port, Victor Basili, Apurva Jain, "Achieving CMMI Level 5 Improvements with MBASE and the CeBASE Method," CrossTalk, May 2002 (pdf)
Each branch of service in the Department of Defense has major initiatives to pursue more advanced software-intensive systems concepts involving network-centric warfare with self adaptive networks and cooperating human and autonomous agents. The ability to balance discipline and flexibility is critically important to developing such highly dependable software-intensive systems in an environment of rapid change. Risk-management orientation enables users of Capability Maturity Model® IntegrationSM (CMMISM) to apply risk considerations to determine how much discipline and how much flexibility is enough in a given situation. The risk-driven nature of the spiral model and MBASE enables them to achieve a similar balance of discipline and flexibility. When these project-level approaches are combined with the organization-level approaches in the Experience Factory, the result is the unified Center for Empirically Based Software Engineering (CeBASE) method described in this article.
Added May 23rd, 2002
USC-CSE-2001-510 - Software Defect Reduction Top 10 List (Victor R. Basili, Barry Boehm)
Victor R. Basili, Barry Boehm, "Software Defect Reduction Top 10 List," Computer, January 2001, pp. 135-137 (pdf, doc)
Recently, a National Science Foundation grant enabled us to establish the Center for Empirically Based Software Engineering. CeBASE seeks to transform software engineering as much as possible from a fad-based practice to an engineering-based practice through derivation, organization, and dissemination of empirical data on software development and evolution phenomenology. The phrase “as much as possible” reflects the fact that software development must remain a people-intensive and continually changing field. We have found, however, that researchers have established objective and quantitative data, relationships, and predictive models that help software developers avoid predictable pitfalls and improve their ability to predict and control efficient software projects.
Added June 24th, 2004
USC-CSE-2001-504 - COTS-Based Systems Top 10 List (Victor Basili, Barry Boehm)
Victor Basili, Barry Boehm, "COTS-Based Systems Top 10 List," Computer, Volume 34, Number 5, May, 2001, pp. 91-93 (pdf
In the January 2001 issue of Computer (pp. 135-137), we published the Software Defect Reduction Top 10 List—one of two foci pursued by the National Science Foundation-sponsored Center for Empirically Based Software Engineering (CeBASE).
COTS-based systems (CBS) provide the other CeBASE focus. For our intent, COTS software has the following characteristics: The buyer has no access to the source code; the vendor controls its development; and it has a nontrivial installed base (that is, more than one customer; more than a few copies).
Added May 15th, 2001
USC-CSE-2001-503 - The CeBASE Framework for Strategic Software Development and Evolution (Barry Boehm, Victor Basili)
Barry Boehm, Victor Basili, "The CeBASE Framework for Strategic Software Development and Evolution" (pdf)
One of the challenges highlighted in the EDSER-3 Call for Papers is for a symmetric approach to cost, risk, benefit, and opportunity modeling and management. This position paper offers the CeBASE Method as a response to this challenge. It is the result of an effort by the CeBASE principals at USC and U. of Maryland to reconcile their various models of software phenomenology into a common framework for pursuing empirical software engineering research and for organizing the results into a useful experience base.
Added May 15th, 2001
USC-CSE-2000-511 - Gaining Intellectual Control of Software Development (Barry Boehm, Victor R. Basili)
Barry Boehm, Victor R. Basili "Gaining Intellectual Control of Software Development," IEEE Computer, Volume 33, Number 5, May 2000, pp. 27-33 (pdf)
Recent disruptions caused by several events have shown how thoroughly the world has come to depend on software. The rapid proliferation of the Melissa virus hinted at a dark side to the ubiquitous connectivity that supports the information-rich Internet and lets e-commerce thrive. Although the oft-predicted Y2K apocalypse failed to materialize, many software experts insist that disaster was averted only because countries around the globe spent billions to ensure their critical software would be Y2K-compliant. When denial-of-service attacks shut down some of the largest sites on the Web last February, the concerns caused by the disruptions spread far beyond the complaints of frustrated customers, affecting even the stock prices of the targeted sites.
Added October 10th, 2000
Kent Beck
USC-CSE-2003-518 - Agility Through Discipline: A Debate (Barry Boehm, Kent Beck)
Barry Boehm, Kent Beck, "Agility Through Discipline: A Debate," Computer, June 2003, pp. 44-46 (pdf)
Kent says: There are those who see agility in software development as a tradeoff, a sort of shaving of the wing spars. By giving up safety or rigor or accountability, we can go faster. From inside Extreme Programming, though, “agility or safety” or “agility or discipline” look like false dichotomies. From inside Extreme Programming, it seems that the only way to achieve the results we seek is to view the world in “both-and” terms instead of “either-or” terms. Why this disconnect?
Added June 24th, 2004
Nels Beckman
USC-CSE-2004-509 - GLIDE: A Grid-based Lightweight Infrastructure for Data-intensive Environments (Chris A. Mattmann, Sam Malek, Nels Beckman, Marija Mikic-Rakic, Nenad Medvidovic, Dan Crichton)
Chris A. Mattmann, Sam Malek, Nels Beckman, Marija Mikic-Rakic, Nenad Medvidovic, Dan Crichton, "GLIDE: A Grid-based Lightweight Infrastructure for Data-intensive Environments," Proceedings of the European Grid Conference (EGC2005), Amsterdam, the Netherlands, February 14th-16th, 2005, pp. 68-77 (pdf)
The promise of the grid is that it will enable public access and sharing of immense amounts of computational and data resources among a large number of individuals and institutions. However, the current grid solutions make several limiting assumptions that curtail their widespread adoption in the emerging decentralized, resource constrained, embedded, autonomic, and mobile (DREAM) environments: they are designed primarily for highly complex scientific problems, and therefore require powerful hardware and reliable network connectivity; additionally, they provide no application design support to grid users (e.g., scientists). To address these limitations, we present GLIDE, a prototype light-weight, data-intensive middleware infrastructure that enables access to the robust data and computational power of the grid on DREAM platforms. GLIDE embodies a number of features of an existing data grid solution within the framework of an existing DREAM middleware solution with extensive application design capabilities. We illustrate GLIDE on an example mp3 file sharing application. We discuss our early experience with GLIDE and present a set of open research questions.
Added August 2nd, 2004
USC-CSE-2004-501 - A Tailorable Environment for Assessing the Quality of Deployment Architectures in Highly Distributed Settings (Marija Mikic-Rakic, Sam Malek, Nels Beckman, Nenad Medvidovic)
Marija Mikic-Rakic, Sam Malek, Nels Beckman, Nenad Medvidovic, "A Tailorable Environment for Assessing the Quality of Deployment Architectures in Highly Distributed Settings," Proceedings of the 2nd International Working Conference on Component Deployment (CD 2004), Edinburgh, UK, May 20-21, 2004 (pdf)
A distributed software system’s deployment architecture can have a significant impact on the system’s properties. These properties will depend on various system parameters, such as network bandwidth, frequencies of software component interactions, and so on. Existing tools for representing system deployment lack support for specifying, visualizing, and analyzing different factors that influence the quality of a deployment, e.g., the deployment’s impact on the system’s availability. In this paper, we present an environment that supports flexible and tailorable specification, manipulation, visualization, and (re)estimation of deployment architectures for large-scale, highly distributed systems. The environment has been successfully used to explore large numbers of postulated deployment architectures. It has also been integrated with a middleware platform to support the exploration of deployment architectures of actual distributed systems.
Added February 19th, 2004
Frank C. Belz
USC-CSE-89-504 - Experiences with the Spiral Model as A Process Model Generator (Barry Boehm, Frank Belz)
Barry Boehm, Frank Belz, "Experiences with the Spiral Model as A Process Model Generator," an expanded version of Proceedings of the 5th International Software Process Workshop, 1989. Experience with Software Process Models, October 10-13, 1989, pp. 43-45 (pdf)
Many of the problems on software projects arise from mismatches between the process model used by the project and the project's real-world process drivers, such as budget, schedule, and available commercial off-the-shelf (COTS) software. The primary process modeling approach to date for avoiding these mismatches has been to try to develop the perfect process model: one which will work well for any combination of process drivers.
Our position is that a good process model generator would be nearly as effective as the perfect process model, and much more likely to be achievable. A process model generator is a technique which operates on a project's process drivers as inputs to produce a process model for the project which is tailored to its particular process drivers.
We have had several experiences in using the Spiral Model [Boehm, 19881 as a process model generator. Our initial experience in generating a process model for the TRW Quantum Leap program was reported in the previous workshop [Boehm-Belz, 19883. Subsequent experiences have generated some significantly different process models for avionics, command-control, exploratory research projects, and small fourth-generation language (4GL) based systems.
Below, we provide a short summary of the use of the spiral model as a process model generator, and a summary of the various process model generation experiences in terms of a Process Model Decision Table showing the critical process driver conditions under which the most familiar process models (e.g., waterfall [Royce, 1970], evolutionary development [McCracken-Jackson, 1982], and transform [Balzer-Cheatham-Green, 1988]) are the appropriate choice of a process model for a particular software project.
Added June 18th, 2008
USC-CSE-88-502 - Applying Process Programming to the Spiral Model (Barry Boehm, Frank Belz)
The primary thesis of this position paper is that process programming is analogous to programming in an key respect not previously emphasized: that it will proceed more effectively if preceded by a set of activities to determine the requirements, architecture, and design of the process.
Added June 18th, 2008
USC-CSE-87-501 - Next Generation Software Environment: Principles, Problems, and Research (Richard N. Taylor, Deborah A. Baker, Frank C. Belz, Barry Boehm, Lori A. Clarke, David A. Fischer, Leon J. Osterweil, Richard Selby, Jack C. Wileden, Alexander L. Wolf, Michal Young)
Richard N. Taylor, Deborah A. Baker, Frank C. Belz, Barry Boehm, Lori A. Clarke, David A. Fischer, Leon J. Osterweil, Richard Selby, Jack C. Wileden, Alexander L. Wolf, Michal Young, "Next Generation Software Environment: Principles, Problems, and Research," Dep. Inform. Comput. Sci., Univ. Calif., Irvine, CA, Tech. Rep. 87-16, July 1987, also issued as Arcadia Doc. UCI-87-10, Univ. Colorado Tech. Rep. CU-CS-370- 87, Univ. Mass., Amherst, Tech. Rep. 87-63, and Incremental Systems Corp. Tech. Rep. 87-7-1 (pdf)
The past decade has seen a burgeoning of research and development in software environments. Conferences have been devoted to the topic of practical environments, journal papers produced, and commercial systems sold. Given all the activity, one might expect a great deal of consensus on issues, approaches, and techniques. This is not the case, however. Indeed, the term "environment" is still used in a variety of conflicting ways. Nevertheless substantial progress has been made and we are at least nearing consensus on many critical issues.
The purpose of this paper is to characterize environments, describe several important principles that have emerged in the last decade or so, note current open problems, and describe some approaches to these problems, with particular emphasis on the activities of one large-scale research program, the Arcadia project. Consideration is also given to two related topics: empirical evaluation and technology transition. That is, how can environments and their constituents be evaluated, and how can new developments be moved effectively into the production sector?
Added June 18th, 2008
Herbert D. Benington
USC-CSE-83-501 - Production of Large Computer Programs (Herbert D. Benington)
The paper is adapted from a presentation at a symposium on advanced programming methods for digital computers sponsored by the Navy Mathematical Computing Advisory Panel and the Office of Naval Research in June 1956. The author describes the techniques used to produce the programs for the Semi-Automatic Ground Environment (SAGE) system.
Added June 6th, 2008
Salah Bendifallah
USC-CSE-93-498 - Next-Generation Software Processes and Their Environment Support (Barry Boehm, Prasanta Bose, Ellis Horowitz, Walter Scacchi, Salah Bendifallah, Azad Madni)
Barry Boehm, Prasanta Bose, Ellis Horowitz, Walter Scacchi, Salah Bendifallah, Azad Madni, "Next-Generation Software Processes and Their Environment Support," Proceedings, USC Center for Software Engineering Inaugural Convocation, June 1993 (pdf)
This paper discusses the shortfalls involved with current software process models, and describes a USC research project to develop a Next-Generation Process Model (NGPMl ) addressing these shortfalls. The NGPM emphasizes collaborative software processes. Its conceptual basis is a set of Theory W (win-win) extensions to the Sprial Model of software development.
The paper also discusses concepts and approaches for developing a Next-Generation Process Support System (NGPSS), a groupware-oriented support capability for the NGPM. It describes an approach for collaborative win-condition elicitation and resolution with respect to a prospective software product's constituents or stakeholders (users, customers, developers, maintainers, interfacers, etc.). This approach is based the Theory W steps of win-condition identification; expectations management; collaborative creation, analysis, and negotiation of win-win solutions; and management of win-lose or lose-lose risks.
The NGPSS is elaborated into a candidate set of of user interface screens and collaborative support capabilities, based on Perceptronics' Computer Aided Concurrent Engineering (CACEIPM®2 ) toolset. A candidate top-level NGPSS architecture is also presented, including an approach for integrating the NGPSS capabilities into current and evolving software environment capabilites.
Added June 25th, 2008
Jesal Bhuta
USC-CSSE-2008-829 - Balancing Opportunities and Risks in Component-Based Software Development (Barry Boehm, Jesal Bhuta)
Barry Boehm, Jesal Bhuta, "Balancing Opportunities and Risks in Component-Based Software Development," IEEE Software, November-December 2008, Volume 15, Issue 6, pp. 56-63 (pdf)
The increasingly rapid change in information technology makes it essential for software development projects to continuously monitor and adapt to new sources of opportunity and risk. Software projects and organizations can increase their success rates in software development by better assessing and balancing their opportunities and risks. The authors summarize the incremental commitment model (ICM), a process framework for improved project monitoring and decision making based on balancing opportunities and risks. They give an example of how the ICM framework can improve component-based development choices based on assessment of opportunities and risks. They show how different opportunistic solutions result from different stakeholder value propositions. They elaborate on the risks involved in architectural mismatches among components, present a tool called the Integration Studio (iStudio) that enables projects to assess the most common sources of architectural mismatch between components. Finally, they present representative examples of its use.
Added January 26th, 2009
USC-CSSE-2007-736 - A Framework for Identification and Resolution of Interoperability Mismatches in COTS-Based Systems (Jesal Bhuta, Barry Boehm)
Jesal Bhuta, Barry Boehm, "A Framework for Identification and Resolution of Interoperability Mismatches in COTS-Based Systems," 2nd International Workshop on Incorporating COTS Software into Software Systems: Tools and Techniques (co-located with the 29th International Conference on Software Engineering), Minneapolis, May 2007 (pdf)
Software systems today are frequently composed from prefabricated commercial components that provide complex functionality and engage in complex interactions. Such projects that utilize multiple commercial-off-the-shelf (COTS) products often confront interoperability conflicts resulting in budget and schedule overruns. These conflicts occur because of the incompatible assumptions made by developers of these products. Identification of such conflicts and planning strategies to resolve them is critical for developing such systems under budget and schedule constraints. In this paper we present an attribute-based framework that can be used to perform high-level and automated interoperability assessment to filter out COTS product combinations whose integration will not be feasible within the project constraints. Our framework is built upon standard definitions of both COTS components and connectors and is intended for use by architects and developers during the design phase of a software system. Our preliminary experience in using the framework indicates an increase in interoperability assessment productivity by 50% and accuracy by 20%.
Jesal Bhuta, Barry Boehm, "Attribute-Based COTS Product Interoperability Assessment," International Conference on COTS-Based Software Systems, Alberta, Canada, February/March 2007 (pdf)
Software systems today are frequently composed from prefabricated commercial components that provide complex functionality and engage in complex interactions. Such projects that utilize multiple commercial-off-the-shelf (COTS) products often confront interoperability conflicts resulting in budget and schedule overruns. These conflicts occur because of the incompatible assumptions made by developers of these products. Identification of such conflicts and planning strategies to resolve them is critical for developing such systems under budget and schedule constraints. Unfortunately, acquiring information to perform interoperability analysis is a time-intensive process. Moreover, increase in the number of COTS products available to fulfill similar functionality leads to hundreds of COTS product combinations, further complicating the COTS interoperability assessment landscape. In this paper we present a set of attributes that can be used to define COTS interoperability-specific characteristics. COTS product definitions based on these attributes can be used to perform high-level and automated interoperability assessment to filter out COTS product combinations whose integration will not be feasible within project constraints. In addition to above stated attributes, we present a tool that can be used to assess COTS-based architectures for interoperability conflicts, reducing the overall effort spent in performing interoperability analysis. Our preliminary experience in using the framework indicates an increase in interoperability assessment productivity by 50% and accuracy by 20%.
Added February 22nd, 2008
USC-CSE-2006-615 - A Framework for the Assessment and Selection on Software Compononents and Connectors in COTS-Based Architectures (Jesal Bhuta, Chris A. Mattmann, Nenad Medvidovic, Barry Boehm)
Jesal Bhuta, Chris A. Mattmann, Nenad Medvidovic, Barry Boehm, "A Framework for the Assessment and Selection on Software Compononents and Connectors in COTS-Based Architectures," Sixth Working IEEE/IFIP Conference on Software Architecture, Mumbai, India (pdf)
Software systems today are composed from prefabricated commercial components and connectors that provide complex functionality and engage in complex interactions. Unfortunately, because of the distinct assumptions made by developers of these products, successfully integrating them into a software system can be complicated, often causing budget and schedule overruns. A number of integration risks can often be resolved by selecting the 'right' set of COTS components and connectors that can be integrated with minimal effort. In this paper we describe a framework for selecting COTS software components and connectors ensuring their interoperability in software-intensive systems. Our framework is built upon standard definitions of both COTS components and connectors and is intended for use by architects and developers during the design phase of a software system. We highlight the utility of our framework using a challenging example from the data-intensive systems domain. Our preliminary experience in using the framework indicates an increase in interoperability assessment productivity by 50% and accuracy by 20%.
Added September 19th, 2006
USC-CSE-2006-608 - A Framework for Intelligent Assessment and Resolution of Commercial Off-The-Shelf (COTS) Product Incompatibilities (Jesal Bhuta)
Jesal Bhuta, "A Framework for Intelligent Assessment and Resolution of Commercial Off-The-Shelf (COTS) Product Incompatibilities" (pdf)
Boehm and Scherlis in [Boehm and Scherlis 1992] introduced Megaprogramming, the practice of software construction in a component-oriented fashion heavily based on software reuse. It is an effective technique of reducing long-term software development cost, improving software quality, and reducing development time. One critical factor that influences the success of megaprogramming is the effort taken to actually reuse available software components. This process entails the identification of the requirements to be satisfied by the component, selection of a component that satisfies these requirements, and using it appropriately in the system. Some challenges in the past reuse attempts have been in identifying the amount of effort required to develop reusable components, estimating the number of components to reuse, effectively selecting these components and adapting the components to differences in domain and/or architectural assumptions.
Added June 16th, 2006
USC-CSE-2005-515 - Value-Based Processes for COTS-Based Applications (Ye Yang, Jesal Bhuta, Barry Boehm, Dan Port)
Ye Yang, Jesal Bhuta, Barry Boehm, Dan Port, "Value-Based Processes for COTS-Based Applications," IEEE Software, Volume 22, Issue 4, July-August 2005, pp. 54-62 (pdf)
Economic imperatives are changing the nature of software development processes to reflect both the opportunities and challenges of using COTS products. Processes are increasingly moving away from the time-consuming composition of custom software from lines of code (although these processes still apply for developing the COTS products themselves) toward assessment, tailoring, and integration of COTS or other reusable components. Two factors are driving this change: COTS or other reusable components can provide significant user capabilities within limited costs and development time, and more COTS products are becoming available to provide needed user functions.
Added November 11th, 2005
USC-CSE-2004-518 - Using Empirical Testbeds to Accelerate Technology Maturity and Transition: The SCRover Experience (Barry Boehm, Jesal Bhuta, David Garlan, Eric Gradman, LiGuo Huang, Alexander Lam, Ray Madachy, Nenad Medvidovic, Kenneth Meyer, Steven Meyers, Gustavo Perez, Kirk Reinholtz, Roshanak Roshandel, Nicolas Rouquette)
Barry Boehm, Jesal Bhuta, David Garlan, Eric Gradman, LiGuo Huang, Alexander Lam, Ray Madachy, Nenad Medvidovic, Kenneth Meyer, Steven Meyers, Gustavo Perez, Kirk Reinholtz, Roshanak Roshandel, Nicolas Rouquette, "Using Empirical Testbeds to Accelerate Technology Maturity and Transition: The SCRover Experience," Proceedings of the 2004 International Symposium on Empirical Software Engineering, ISESE'04, August 19-20 2004, pp. 117-126 (pdf)
This paper is an experience report on a first attempt to develop and apply a new form of software: a full-service empirical testbed designed to evaluate alternative software dependability technologies, and to accelerate their maturation and transition into project use. The SCRover testbed includes not only the specifications, code, and hardware of a public safety robot, but also the package of instrumentation, scenario drivers, seeded defects, experimentation guidelines, and comparative effort and defect data needed to facilitate technology evaluation experiments.
The SCRover testbed's initial operational capability has been recently applied to empirically evaluate two architecture definition languages (ADLs) and toolsets, Mae and AcmeStudio. The testbed evaluation showed (1) that the ADL-based toolsets were complementary and cost-effective to apply to mission-critical systems; (2) that the testbed was cost-effective to use by researchers; and (3) that collaboration in testbed use by researchers and the Jet Propulsion Laboratory (JPL) project users resulted in actions to accelerate technology maturity and transition into project use. The evaluation also identified a number of lessons learned for improving the SCRover testbed, and for development and application of future technology evaluation testbeds.
Added November 14th, 2005
USC-CSE-2003-520 - Composable Process Elements for Developing COTS-Based Applications (Barry Boehm, Dan Port, Ye Yang, Jesal Bhuta, Chris Abts)
Barry Boehm, Dan Port, Ye Yang, Jesal Bhuta, Chris Abts, "Composable Process Elements for Developing COTS-Based Applications," Proceedings, ISESE 2003, September/October 2003 (pdf)
Data collected from five years of developing e-service applications at USC-CSE reveals that an increasing fraction have been commercial-off-the-shelf (COTS)-Based Application (CBA) projects: from 28% in 1997 to 60% in 2001. Data from both small and large CBA projects show that CBA effort is primarily distributed among the three activities of COTS assessment, COTS tailoring, and glue code development and integration, with wide variations in their distribution across projects. We have developed a set of data-motivated composable process elements, in terms of these three activities, for developing CBA's as well an overall decision framework for applying the process elements. We present data regarding the movement towards CBA's and effort distribution among them; we then proceed to describe the decision framework and to present a real-world example showing how it operates within the WinWin Spiral process model generator to orchestrate, execute, and adapt the process elements to changing project circumstances.
Added June 24th, 2004
USC-CSE-2003-507 - Using Testbeds to Accelerate Technology Maturity and Transition: The SCRover Experience (Barry Boehm, Jesal Bhuta, David Garlan, Eric Gradman, LiGuo Huang, Alexander Lam, Ray Madachy, Nenad Medvidovic, Kenneth Meyer, Steven Meyers, Gustavo Perez, Kirk Reinholtz, Roshanak Roshandel, Nicolas Rouquette)
Barry Boehm, Jesal Bhuta, David Garlan, Eric Gradman, LiGuo Huang, Alexander Lam, Ray Madachy, Nenad Medvidovic, Kenneth Meyer, Steven Meyers, Gustavo Perez, Kirk Reinholtz, Roshanak Roshandel, Nicolas Rouquette, "Using Testbeds to Accelerate Technology Maturity and Transition: The SCRover Experience," 2004 ACM-IEEE International Symposium on Empirical Software Engineering, Redondo Beach, CA, August 2004 (pdf)
This paper is an experience report on a first attempt to develop and apply a new form of software: a full service testbed designed to evaluate alternative software dependability technologies, and to accelerate their maturation and transition into project use. The SCRover testbed includes not only the specifications, code, and hardware of a public safety robot, but also the package of instrumentation, scenario drivers, seeded defects, experimentation guidelines, and comparative effort and defect data needed to facilitate technology evaluation experiments.
The SCRover testbed’s initial operational capability has been recently applied to evaluate two architecture definition languages (ADLs) and toolsets, Mae and AcmeStudio. The testbed evaluation showed (1) that the ADL-based toolsets were complementary and cost effective to apply to mission-critical systems; (2) that the testbed was cost-effective to use by researchers; and (3) that collaboration in testbed use by researchers and the Jet Propulsion Laboratory (JPL) project users resulted in actions to accelerate technology maturity and transition into project use. The evaluation also identified a number of lessons learned for improving the SCRover testbed, and for development and application of future technology evaluation testbeds.
Added September 18th, 2003
USC-CSE-2003-501 - Not All CBS Are Created Equally: COTS-Intensive Project Types (Barry Boehm, Dan Port, Ye Yang, Jesal Bhuta)
Barry Boehm, Dan Port, Ye Yang, Jesal Bhuta, "Not All CBS Are Created Equally: COTS-Intensive Project Types," Proceedings of 2nd International Conference on COTS-Based Software Systems, February 2003 (pdf)
COTS products affect development strategies and tactics, but not all CBS development efforts are equal. Based on our experiences with 20 large government and industry CBS projects assessed during our development of the COCOTS estimation model, and our hands-on experience with 52 small e-services CBS projects within USC's graduate level software engineering course, we have identified four distinct CBS activity areas: assessment intensive, tailoring intensive, glue-code intensive, and non-COTS intensive. The CBS activity type fundamentally affects the COTS related activity effort and project risks. In this work we define the three COTS activity intensive CBS types and discuss their strategic comparisons based on an empirical study of the spectrum of large and small CBS projects.
Added February 28th, 2003
Jesal Bhuta's PhD Dissertation - A Framework for Intelligent Assessment and Resolution of Commercial-Off-The-Shelf Product Incompatibilities
A Framework for Intelligent Assessment and Resolution of Commercial-Off-The-Shelf Product Incompatibilities (pdf)
Jesal Bhuta
Software systems today are frequently composed from prefabricated commercial components that provide complex functionality and engage in complicated interactions. Such projects that utilize multiple commercial-off-the-shelf (COTS) products often confront interoperability conflicts resulting in budget and schedule overruns. These conflicts occur because of the incompatible assumptions made by developers during the development of these products. Identification of such conflicts and planning strategies to resolve them is critical for developing such systems under budget and schedule constraints. Unfortunately, acquiring information to perform interoperability analysis is a time-intensive process. Moreover, increase in the number of COTS products available to fulfill similar functionality leads to hundreds of COTS product combinations, further complicating the COTS interoperability assessment activity.
This dissertation motivates, presents and validates an intelligent assessment and resolution framework for Commercial-Off-The-Shelf (COTS) incompatibilities. The framework can be used to perform high-level and automated interoperability assessment to filter out COTS product combinations whose integration will not be feasible within project constraints. The framework efficiently and effectively captures knowledge on COTS product interoperability and allows a user to automatically leverage this knowledge to perform interoperability assessment. The framework elements have been utilized to develop an interoperability assessment tool – Integration Studio.
This framework is empirically validated using controlled experiments and project implementations in 25 projects from small, medium and large network centric systems from diverse business domains. The empirical evidence consistently indicates an increase in interoperability assessment productivity by about 50% and accuracy by 20% in small and medium systems.
August 2007
Barry Boehm
USC-CSSE-2009-515 - Assessing and Estimating Corrective, Enhancive, and Reductive Maintenance Tasks: A Controlled Experiment (Vu Nguyen, Barry Boehm, Phongphan Danphitsanuphan)
Vu Nguyen, Barry Boehm, Phongphan Danphitsanuphan, "Assessing and Estimating Corrective, Enhancive, and Reductive Maintenance Tasks: A Controlled Experiment" (pdf)
This paper describes a controlled experiment of student programmers performing maintenance tasks on a C++ program. The goal of the study is to assess the maintenance size, effort, and effort distribution of three different maintenance types and to describe estimation models to predict the programmer’s effort on maintenance tasks. The results of our study suggest that the corrective maintenance is much less productive than the enhancive and reductive maintenance. Our study also confirms the previous results which conclude that corrective and reductive maintenance requires large proportions of effort on the program comprehension activity. Moreover, the best effort model we obtained from fitting the experiment data can estimate the time of 79% of the maintainers with the error of 30% or less.
Added August 18th, 2009
USC-CSSE-2009-512 - Predicting Understandability of a Software Project: A Comparison of Two Surveys (Ali Afzal Malik, Barry Boehm)
Ali Afzal Malik, Barry Boehm, "Predicting Understandability of a Software Project: A Comparison of Two Surveys" (pdf)
This paper summarizes the results of an empirical study conducted to explore the relative importance of eight pertinent COCOMO II model drivers in predicting the understandability of a software project. Here understandability of the project is measured solely from the perspective of the development team. This empirical study employed a survey that was targeted towards experienced practitioners. Results from this survey are compared with the corresponding results from a prior similar survey conducted on graduate students. While this comparison reveals some interesting differences between the importance given to each of the eight model drivers by these two categories of individuals it also highlights some subtle similarities.
Added June 10th, 2009
USC-CSSE-2009-507 - Bridge the Gap between Software Test Process and Business Value: A Case Study (Qi Li, Mingshu Li, Ye Yang, Qing Wang, Thomas Tan, Barry Boehm, Chenyong Hu)
Qi Li, Mingshu Li, Ye Yang, Qing Wang, Thomas Tan, Barry Boehm, Chenyong Hu, "Bridge the Gap between Software Test Process and Business Value: A Case Study," ICSP2009, Vancouver, Canada, May 16-17, 2009 (pdf)
For a software project to succeed, acceptable quality must be achieved within an acceptable cost, providing business value to the customers, and keeping delivery time short. Software testing is a strenuous and expensive process and is often not organized to maximize business value. In this article, we propose a practical value based software testing method which aligns the internal test process with the value objectives coming from the customers and the market. Our case study in a real-life business project shows that this method helps manage testing process effectively and efficiently.
Added April 20th, 2009
USC-CSSE-2009-506 - An Empirical Analysis of Effort Distribution of Small Real-Client Projects (Ali Afzal Malik, Barry Boehm)
Ali Afzal Malik, Barry Boehm, "An Empirical Analysis of Effort Distribution of Small Real-Client Projects" (pdf)
This paper presents an analysis of the weekly effort distribution of 23 small real-client projects. The procedure used in collecting the effort data is described and the major findings are summarized. The results indicate the crests and troughs of project effort in relation to the major project milestones. Possible reasons for the pecularities in the effort distribution are also discussed. Moreover, an attempt is made to analyze the impact of project type on the effort distribution by comparing the effort profiles of web-based projects with non-web-based projects.
Added April 15th, 2009
USC-CSSE-2009-505 - Software Size Analysis of Small Real-Client Projects (Ali Afzal Malik, Barry Boehm)
Ali Afzal Malik, Barry Boehm, "Software Size Analysis of Small Real-Client Projects" (pdf)
This paper presents an analysis of the results of an empirical study conducted to examine the relationship between the estimated and actual sizes of small real-client projects. Estimates of software size are collected at two different points of the software development life cycle – one immediately before rebaselining the project mid-stream and the other immediately after rebaselining. It is found that estimates made after rebaselining are usually more accurate. The accuracy of estimates based on the category of projects is also analysed. The results indicate that the correlation between estimated and actual size is much stronger in case of web-based projects vis-à-vis non-web-based projects.
Added April 7th, 2009
USC-CSSE-2009-504 - Using Software Project Courses to Integrate Education and Research: An Experience Report (Supannika Koolmanojwong, Barry Boehm)
Supannika Koolmanojwong, Barry Boehm, "Using Software Project Courses to Integrate Education and Research: An Experience Report," 22nd IEEE-CS Conference on Software Engineering Education and Training (CSEET) 2009 (pdf)
At University of Southern California (USC), CSCI577ab is a graduate software engineering course that teaches best software engineering practices and allows students to apply the learned knowledge in developing real-client projects. The class is used as an experimental test-bed to deploy various research tools and approaches for validation of new methods and tools. Various research data have been collected as partial basis for twelve PhD dissertations. This paper reports how research and education are integrated via project experiments and how the results strengthen future educational experiences.
Added March 23rd, 2009
USC-CSSE-2009-502 - A Risk-Driven Process Decision Table to Guide System Development Rigor (Barry Boehm, Jo Ann Lane, Supannika Koolmanojwong)
Barry Boehm, Jo Ann Lane, Supannika Koolmanojwong, "A Risk-Driven Process Decision Table to Guide System Development Rigor," INCOSE 2009 (pdf)
The Incremental Commitment Model (ICM) organizes systems engineering and acquisition processes in ways that better accommodate the different strengths and difficulties of hardware, software, and human factors engineering approaches. As with other models trying to address a wide variety of situations, its general form is rather complex. However, its risk-driven nature has enabled us to determine a set of twelve common risk patterns and organize them into a decision table that can help new projects converge on a process that fits well with their particular process drivers. For each of the twelve special cases, the decision table provides top-level guidelines for tailoring the key activities of the ICM, along with suggested lengths between each internal system build and each external system increment delivery. This paper elaborates on each of the twelve cases and provides examples of their use.
Added March 16th, 2009
USC-CSSE-2009-501 - Better Management of Development Risks: Early Feasibility Evidence (Barry Boehm, Jo Ann Lane)
Barry Boehm, Jo Ann Lane, "Better Management of Development Risks: Early Feasibility Evidence," 7th Annual Conference on Systems Engineering Research 2009 (CSER 2009) (pdf)
The Incremental Commitment Model (ICM) organizes more rapid and thorough concurrent systems engineering and acquisition processes in ways that provide points at which they can synchronize and stabilize, and at which their risks of going forward can be better assessed and fitted into a risk-driven stakeholder resource commitment process. In particular, its concurrent activities of Understanding Needs, Envisioning Opportunities, System Scoping and Architecting, Feasibility Evidence Development, and Risk/Opportunity Assessment enable projects to focus specifically on their system constraints and environments and on opportunities to deal with them. This paper describes in detail the content, preparation, and role of feasibility evidence at key decision points in the system development cycle and how this can be used to effectively identify and manage risks throughout the development cycle. The feasibility evidence is not intended to assess just a single sequentially developed system definition element, but rather to assess the consistency, compatibility, and feasibility of several concurrently-engineered elements. To make this concurrency work, a set of anchor point milestone reviews are performed to ensure that the many concurrent activities are synchronized, stabilized, and risk-assessed at the end of each phase using developer-produced, expert-validated feasibility evidence.
Added March 16th, 2009
USC-CSSE-2009-500 - Guide for Using the Incremental Commitment Model (ICM) for Systems Engineering of DoD Projects (Barry Boehm, Jo Ann Lane)
Barry Boehm, Jo Ann Lane, "Guide for Using the Incremental Commitment Model (ICM) for Systems Engineering of DoD Projects" (pdf)
Future mission-critical DoD combat platforms, systems of systems, and network-centric services will have many usage uncertainties and emergent characteristics. Their hardware, software, and human factors will need to be concurrently engineered, risk-managed, and evolutionarily developed to converge on cost-effective system operations and mission success.
The recent revision of DoDI 5000.02 provides a much improved policy for dealing with these future challenges, including its starting with Needs and Opportunities, its emphasis on early Analysis of Alternatives as an entry condition for Milestone A, its inclusion of a passed Preliminary Design Review as an entry condition for Milestone B, and its emphasis on evolutionary versus single-increment or prespecified increments of development.
These emphases on DoDI 5000.02 are also key emphases in the Incremental Commitment Model (ICM), along with more detailed guidance on how to apply them. The ICM has been developed based on best commercial practices for addressing such future challenges; on discussions with contributors to DoDI 5000.02; on successful use of the ICM principles on previous DoD projects; and on its exploratory use on highly complex, future-precursor, net-centric DoD systems of systems.
The ICM builds on the experience-based critical success factor principles of stakeholder satisficing, incremental definition, iterative evolutionary system growth, concurrent engineering, and evidence-based, risk-driven management milestones. It is not a one-size-fits-all process model, but has risk-driven options at each milestone decision point to enable projects to adapt to their particular situations. It provides a decision table for early determination of common special-case life cycle processes to avoid overkill in project ceremony and documentation.
It also incorporates the strengths of existing V, concurrent engineering, spiral, agile, and lean process models. As with these other models, it is not fully tested for its ability to support DoDI 5000.02 in all project situations, but it has been formulated to make it straightforward to do so.
Added March 16th, 2009
USC-CSSE-2008-836 - Phase Distribution of Software Development Effort (Ye Yang, Mei He, Mingshu Li, Qing Wang, Barry Boehm)
Effort distribution by phase or activity is an important but often overlooked aspect compared to other steps in the cost estimation process. Poor effort allocation is among the major root causes of rework due to insufficiently resourced early activities. This paper provides results of an empirical study on phase effort distribution data of 75 industry projects, from the China Software Benchmarking Standard Group (CSBSG) database. The phase effort distribution patterns and variation sources are presented, and analysis results show some consistency in effects of software size and team size on code and test phase distribution variations, and some considerable deviations in requirements, design, and transition phases, compared with recommendations in the COCOMO model. Finally, this paper discusses the major findings and threats to validity and presents general guidelines in directing effort allocation. Empirical findings from this study are beneficial for stimulating discussions and debates to improve cost estimation and benchmarking practices.
Added February 5th, 2009
USC-CSSE-2008-835 - Predicting Understandability of a Software Project Using COCOMO II Model Drivers (Ali Afzal Malik, Barry Boehm, A. Winsor Brown)
Ali Afzal Malik, Barry Boehm, A. Winsor Brown, "Predicting Understandability of a Software Project Using COCOMO II Model Drivers," 23rd International Forum on COCOMO and Systems/Software Cost Modeling, Los Angeles, October 2008 (pdf)
This paper presents the results of an empirical study undertaken to investigate the utility of COCOMO II model drivers in predicting the understandability of a software project. Understandability is defined as the degree of clarity of the purpose and requirements of a software system to the developers of that system at the end of the Inception phase. COCOMO II scale factors and cost drivers relevant for prediction are shortlisted and a weighted-sum formula relating these model drivers to understandability is derived through voting. The utility of this formula is judged by examining the COCOMO II model drivers of 24 real-client, MS-student, team projects done at USC. It is found that the weighted-sum formula correctly predicts the understandability of a software project in more than 80% of the cases suggesting a strong relationship between the shortlisted COCOMO II model drivers and the understandability of a software project. This objective way of measuring the understandability of a software project can be extremely useful in determining the time when it is safe to minimize the effort spent on requirements engineering activities.
Added February 2nd, 2009
USC-CSSE-2008-834 - How to Avoid Drastic Software Process Change (using Stochastic Stability) (Tim Menzies, Steve Williams, Oussama Elrawas, Barry Boehm, Jairus Hihn)
Tim Menzies, Steve Williams, Oussama Elrawas, Barry Boehm, Jairus Hihn, "How to Avoid Drastic Software Process Change (using Stochastic Stability)" (pdf)
Before performing drastic changes to a project, it is worthwhile to thoroughly explore the available options within the current structure of a project. An alternative to drastic change are internal changes that adjust current options within a software project. In this paper, we show that the effects of numerous internal changes can out-weigh the effects of drastic changes. That is, the benefits of drastic change can often be achieved without disrupting a project.
The key to our technique is SEESAW, a novel stochastic stability tool that (a) considers a very large set of minor changes using stochastic sampling; and (b) carefully selects the right combination of effective minor changes.
Our results show, using SEESAW, project managers have more project improvement options than they currently realize. This result should be welcome news to managers struggling to maintain control and continuity over their project in the face of multiple demands for drastic change.
Added February 2nd, 2009
USC-CSSE-2008-833 - Accurate Estimates without Calibration? (Tim Menzies, Oussama Elrawas, Barry Boehm, Raymond Madachy, Jairus Hihn, Daniel Baker, Karen Lum)
Tim Menzies, Oussama Elrawas, Barry Boehm, Raymond Madachy, Jairus Hihn, Daniel Baker, Karen Lum, "Accurate Estimates without Calibration?" Lecture Notes in Computer Science, Making Globally Distributed Software Development a Success Story, Volume 5007, 2008, Springer Belin / Heidelberg, pp. 210-221 (pdf)
Most process models calibrate their internal settings using historical data. Collecting this data is expensive, tedious, and often an incomplete process.
Is it possible to make accurate software process estimates without historical data? Suppose much of uncertainty in a model comes from a small subset of the model variables. If so, then after (a) ranking variables by their ability to constrain the output; and (b) applying a small number of the top-ranked variables; then it should be possible to (c) make stable predictions in the constrained space.
To test that hypothesis, we combined a simulated annealer (to generate random solutions) with a variable ranker. The results where quite dramatic: in one of the studies in this paper, we found process options that reduced the median and variance of the effort estimates by a factor of 20. In ten case studies, we show that the estimates generated in this manner are usually similar to those produced by standard local calibration.
Our conclusion is that while it is always preferable to tune models to local data, it is possible to learn process control options without that data.
Added January 29th, 2009
USC-CSSE-2008-831 - Achievements and Challenges in Cocomo-Based Software Resource Estimation (Barry Boehm, Ricardo Valerdi)
Barry Boehm, Ricardo Valerdi, "Achievements and Challenges in Cocomo-Based Software Resource Estimation," IEEE Software, Volume 25, Number 5, September 2008, pp. 74-83 (pdf)
This article summarizes major achievements and challenges of software resource estimation over the last 40 years, emphasizing the Cocomo suite of models. Critical issues that have enabled major achievements include the development of good model forms, criteria for evaluating models, methods for integrating expert judgment and statistical data analysis, and processes for developing new models that cover new software development approaches. The article also projects future trends in software development and evolution processes, along with their implications and challenges for future software resource estimation capabilities.
Added January 26th, 2009
USC-CSSE-2008-830 - Assessing Quality Processes with ODC COQUALMO (Ray Madachy, Barry Boehm)
Ray Madachy, Barry Boehm, "Assessing Quality Processes with ODC COQUALMO," Lecture Notes in Computer Science, Making Globally Distributed Software Development a Success Story, Volume 5007, 2008, Springer Belin / Heidelberg, pp. 198-209 (pdf)
Software quality processes can be assessed with the Orthogonal Defect Classification COnstructive QUALity MOdel (ODC COQUALMO) that predicts defects introduced and removed, classified by ODC types. Using parametric cost and defect removal inputs, static and dynamic versions of the model help one determine the impacts of quality strategies on defect profiles, cost and risk. The dynamic version provides insight into time trends and is suitable for continuous usage on a project. The models are calibrated with empirical data on defect distributions, introduction and removal rates; and supplemented with Delphi results for detailed ODC defect detection efficiencies. This work has supported the development of software risk advisory tools for NASA flight projects. We have demonstrated the integration of ODC COQUALMO with automated risk minimization methods to design higher value quality processes, in shorter time and with fewer resources, to meet stringent quality goals on projects.
Added January 26th, 2009
USC-CSSE-2008-829 - Balancing Opportunities and Risks in Component-Based Software Development (Barry Boehm, Jesal Bhuta)
Barry Boehm, Jesal Bhuta, "Balancing Opportunities and Risks in Component-Based Software Development," IEEE Software, November-December 2008, Volume 15, Issue 6, pp. 56-63 (pdf)
The increasingly rapid change in information technology makes it essential for software development projects to continuously monitor and adapt to new sources of opportunity and risk. Software projects and organizations can increase their success rates in software development by better assessing and balancing their opportunities and risks. The authors summarize the incremental commitment model (ICM), a process framework for improved project monitoring and decision making based on balancing opportunities and risks. They give an example of how the ICM framework can improve component-based development choices based on assessment of opportunities and risks. They show how different opportunistic solutions result from different stakeholder value propositions. They elaborate on the risks involved in architectural mismatches among components, present a tool called the Integration Studio (iStudio) that enables projects to assess the most common sources of architectural mismatch between components. Finally, they present representative examples of its use.
Added January 26th, 2009
USC-CSSE-2008-828 - A Process Decision Table for Integrated Systems and Software Engineering (Barry Boehm, Jo Ann Lane)
Barry Boehm, Jo Ann Lane, "A Process Decision Table for Integrated Systems and Software Engineering," Conference on Systems Engineering Research (pdf)
The Incremental Commitment Model (ICM), developed in a recent National Research Council study on integrating human factors into the systems development process, organizes systems engineering and acquisition processes in ways that better accommodate the different strengths and difficulties of hardware, software, and human factors engineering approaches. As with other models trying to address a wide variety of situations, its general form is rather complex. However, its risk-driven nature has enabled us to determine a set of ten common risk patterns and organize them into a decision table that can help new projects converge on a process that fits well with their particular process drivers. For each of the ten special cases, the decision table provides top-level guidelines for tailoring the key activities of the ICM, along with suggested lengths between each internal system build and each external system increment delivery. This paper elaborates on each of the ten cases and provides examples of their use.
Added January 21st, 2009
USC-CSSE-2008-826 - Modern Tools to Support DoD Software Intensive System of Systems Cost Estimation (Jo Ann Lane, Barry Boehm)
Jo Ann Lane, Barry Boehm, "Modern Tools to Support DoD Software Intensive System of Systems Cost Estimation," SoftwareTech, Volume 11, Number 3, pp. 4-13 (pdf)
Many Department of Defense (DoD) organizations are attempting to provide new system capabilities through the net-centric integration of existing software-intensive systems into a new system often referred to as Software-Intensive System of Systems (SISOS). The goal of this approach is to build on existing capabilities to produce new capabilities not provided by the existing systems in a timely and cost-effective manner. Many of these new SISOS efforts such as the Future Combat Systems are of a size and complexity unlike their predecessor systems and cost estimation tools such as the Constructive Cost Model (COCOMO) suite are undergoing significant enhancements to address these challenges. This article describes the unique challenges of SISOS cost estimation, how current tools are changing to support these challenges, as well as on-going efforts to further support SISOS cost estimation needs. It summarizes key information in DACS Report Number 347336.
Added January 21st, 2009
USC-CSSE-2008-817 - ODC COQUALMO - A Software Defect Introduction and Removal Model using Orthogonal Defect Classification (Ray Madachy, Barry Boehm)
Ray Madachy, Barry Boehm, "ODC COQUALMO - A Software Defect Introduction and Removal Model using Orthogonal Defect Classification" (pdf)
Software quality processes can be assessed with the Orthogonal Defect Classification COnstructive QUALity MOdel (ODC COQUALMO) that predicts defects introduced and removed, classified by ODC types. Using parametric cost and defect removal inputs, static and dynamic versions of the model help one determine the impacts of quality strategies on defect profiles, cost and risk. The dynamic version provides insight into time trends and is suitable for continuous usage on a project. The models are calibrated with empirical data on defect distributions, introduction and removal rates; and supplemented with Delphi results for detailed ODC defect detection efficiencies. This work has supported the development of software risk advisory tools for NASA flight projects. We have demonstrated the integration of ODC COQUALMO with automated risk minimization methods to design higher value quality processes, in shorter time and with fewer resources, to meet stringent quality goals on projects.
Added December 22nd, 2008
USC-CSSE-2008-816 - Comparative Analysis of COCOMO II, SEER-SEM and True-S Software Cost Models (Ray Madachy, Barry Boehm)
We have been assessing the strengths, limitations, and improvement needs of cost, schedule, quality and risk models for NASA flight projects. The primary cost models used in this domain for critical flight software are COCOMO II, SEER-SEM and True S. A comparative survey and analysis of these models against a common database of NASA projects was undertaken. A major part of this work is defining transformations between the different models by the use of Rosetta Stones that describe the mappings between their cost factors.
With these Rosetta Stones, projects can be represented in all models in a fairly consistent manner and differences in their estimates better understood. Top-level Rosetta Stones map the factors between the models, and the detailed ones map the individual ratings between the corresponding factors. Most of the Rosetta Stone mappings between factors are one to one, but some are one to many.
The Rosetta Stones we have developed so far allow one to convert COCOMO II estimate inputs into corresponding SEER-SEM or True S inputs, or vice-versa. NASA data came in the COCOMO format and was converted to SEER-SEM and True S factors per the Rosetta Stones.
This initial study was largely limited to a COCOMO viewpoint. The current Rosetta Stones need further review and have to deal with incommensurate quantities from model to model. The cost models performed well when assessed against the NASA data despite these drawbacks, the absence of contextual data and potential flaws in the factor transformations.
The current set of Rosetta Stones has provided a usable framework for analysis, but more should be done including developing two-way and/or multiple-way Rosetta Stones, and partial factor-to-factor mappings. Factors unique to some models should be addressed and detailed translations between the size inputs should be developed including COTS and reuse sizing. Remaining work also includes elaborating the detailed Rosetta Stone for the new True S model, and rigorous review of all the top-level and detailed Rosetta Stones.
Conclusions for existing model usage and new model development are provided. In practice no one model should be preferred over all others, and it is best to use a variety of methods. Future work involves repeating the analysis with the refined Rosetta Stones, updated calibrations, improved models and new data.
Added September 19th, 2008
USC-CSSE-2008-815 - Experimental Evaluation of Wiki Technology and the Shaper Role in Collaborative Requirements Negotiation (Di Wu, Da Yang, Supannika Koolmanojwong, Barry Boehm)
Di Wu, Da Yang, Supannika Koolmanojwong, Barry Boehm, "Experimental Evaluation of Wiki Technology and the Shaper Role in Collaborative Requirements Negotiation" (pdf)
Wiki has been successfully used in a variety of collaboration tasks in corporate context. Studies of corporate wiki users identified the role of shaping as a critical success factor. However, little is known about how wiki and the shaping role can benefit software requirements negotiation activities. Following our initial development of a wiki-based requirements negotiation support tool – WikiWinWin, we experimented with the use of wiki and the shaping role to engage stakeholders in requirements negotiations in the graduate software engineering course at University of Southern California (USC). Our initial experience with 20 real-client projects shows promising results with room for improvements.
Added August 8th, 2008
USC-CSSE-2008-814 - The Macro Risk Model: An Early Warning Tool for Software-Intensive Systems Projects (Barry Boehm, Dan Ingold, Raymond Madachy)
Barry Boehm, Dan Ingold, Raymond Madachy, "The Macro Risk Model: An Early Warning Tool for Software-Intensive Systems Projects," INCOSE 2008 (pdf)
The Macro Risk Model is a tool for early detection and quantification of project risks associated with Software-Intensive Systems (SIS). It has been calibrated and validated against detailed case studies. Structured questions guide a user in rating evidence and risk impacts with respect to critical project success factors. It provides color-coded risk exposures, and allows for rationale and supporting artifacts. This paper describes the model and the basis of its risk evaluation methods, it reviews case studies of NASA exploration mission failures with respect to the model, it discusses a Delphi consensus-seeking process that was used to analyze factors affecting model accuracy and to calibrate the model, and compares the model to other risk approaches.
Added May 28th, 2008
USC-CSSE-2008-811 - Cost Estimation for Secure Software & Systems (Ed Colbert, Barry Boehm)
Ed Colbert, Barry Boehm, "Cost Estimation for Secure Software & Systems," ISPA / SCEA 2008 Joint International Conference (pdf)
The Center for Software Engineering (CSSE) at the University of Southern California (USC) is extending the widely–used Constructive Cost Model version 2 (COCOMO II) [4] to account for developing secure software. CSSE is also developing a model for estimating the cost to acquire secure systems (emphasizing space systems), and is evaluating the effect of security goals on other models in the COCOMO family. We will present the work to date.
Added May 12th, 2008
USC-CSSE-2008-810 - Proposed Modification to COSYSMO Estimating Relationship (Gan Wang, Ricardo Valerdi, Barry Boehm, Alex Shernoff)
Gan Wang, Ricardo Valerdi, Barry Boehm, Alex Shernoff, "Proposed Modification to COSYSMO Estimating Relationship," INCOSE Symposium, June 2008 (pdf)
This paper proposes a modification to the Academic COSYSMO estimating relationship to remedy a critical limitation in its current implementation of the cost drivers. The effort multipliers defined for these drivers have an overdramatic impact on the nominal effort, which unrealistically amplifies or compresses the effort estimate. This problem severely limits its practical applications. The newly proposed parametric relationship is inspired by the COCOMO II modeling approach and based on the considerations of the life cycle impact of the cost drivers. Two additional cost drivers are also introduced. The feasibility of the new model definition is examined with a boundary analysis and validated by the analysis of historical data.
In this paper, we present (1) an analysis of the problem with the current Academic COSYSMO model definition; (2) proposed addition of two new cost drivers to the model; (3) an analysis of life cycle impact of the cost drivers and an organization of the drivers based on the impact; (4) the modified COSYSMO parametric relationship; (5) validation of the modified relationship through an analysis of historical data; and (6) conclusion and suggestion of future work. This work is based on the practical implementation of COSYSMO at BAE Systems.
Added April 25th, 2008
USC-CSSE-2008-809 - A Research Agenda for Systems of Systems Architecting (Ricardo Valerdi, Elliot Axelband, Thomas Baehren, Barry Boehm, Dave Dorenbos, Scott Jackson, Azad Madni, Gerald Nadler, Paul Robitaille, Stan Settles)
Ricardo Valerdi, Elliot Axelband, Thomas Baehren, Barry Boehm, Dave Dorenbos, Scott Jackson, Azad Madni, Gerald Nadler, Paul Robitaille, Stan Settles, "A Research Agenda for Systems of Systems Architecting," International Journal of System of Systems Engineering, 2008 (pdf)
This paper, documents the activity of a workshop on defining a research agenda for Systems of Systems SoS; Architecting, which was held at USC in October 2006. After two days of invited talks on critical success factors for SoS engineering, the authors of this paper convened for one day to brainstorm topics for the purpose of shaping the near-term research agenda of the newly convened USC Center for Systems and Software Engineering (CSSE). The output from the workshop is a list of ten high-impact items with corresponding research challenges in the context of SoS Architecting. Each item includes a description of the research challenges, its link to contemporary academic or industrial problems and reasons for advocacy of that area. The items were assessed in terms of value and difficulty to determine a prioritisation both for the CSSE's future research agenda and for others in the field.
Added April 21st, 2008
USC-CSSE-2008-808 - The ROI of Systems Engineering: Some Quantitative Results for Software-Intensive Systems (Barry Boehm, Ricardo Valerdi, Eric Honour)
Barry Boehm, Ricardo Valerdi, Eric Honour, "The ROI of Systems Engineering: Some Quantitative Results for Software-Intensive Systems," 2008 Wiley Periodicals, Inc. (pdf)
This paper presents quantitative results on the return on investment of systems engineering (SE-ROI) from an analysis of the 161 software projects in the COCOMO II database. The analysis shows that, after normalizing for the effects of other cost drivers, the cost difference between projects doing a minimal job of software systems engineering - as measured by the thoroughness of its architecture definition and risk resolution - and projects doing a very thorough job was 18% for small projects and 92% for very large software projects as measured in lines of code. The paper also presents applications of these results to project experience in determining how much up front systems engineering is enough for baseline versions of smaller and larger software projects, for both ROI-driven internal projects and schedule-driven outsourced systems of systems projects.
Added April 16th, 2008
USC-CSSE-2008-807 - System Development Process: The Incremental Commitment Model (Barry Boehm)
The ultimate goal of system development is to deliver a system that satisfies the needs of its operational stakeholders-users, operators, administrators, maintainers, interoperators, the general public-within satisfactory levels of the resources of its development stakeholders-funders, acquirers, developers, suppliers, others. From the human-system integration perspective, satisfying operational stakeholders' needs can be broadly construed to mean a system that is usable and dependable; permits few or no human errors; and leads to high productivity and adaptability. Developing and delivering systems that simultaneously satisfy all of these success-critical stakeholders usually requires managing a complex set of risks such as usage uncertainties, schedule uncertainties, supply issues, requirements changes, and uncertainties associated with technology maturity and technical design. Each of these areas poses a risk to the delivery of an acceptable operational system within the available budget and schedule. End-state operational system risks can be categorized as uncertainties in achieving a system mission, carrying out the work processes, operating within various constraints such as cost or personnel, satisfying operational stakeholders, or achieving an acceptable operational return on investment.
This chapter summarizes the study's analysis of candidate system design, development, and evolution processes with respect to a set of study-derived critical success factor principles for support of human-intensive system development. It presents the results of synthesizing the contributions of these models along with key human factors processes into an Incremental Commitment Model that is used as a process framework for application of the study's recommended processes, methods, and tools, and for illustrating their successful application in several human-system design case studies (see Chapter 5).
Added April 7th, 2008
USC-CSSE-2008-806 - A Constrained Regression Technique for COCOMO Calibration (Vu Nguyen, Bert Steece, Barry Boehm)
Vu Nguyen, Bert Steece, Barry Boehm, "A Constrained Regression Technique for COCOMO Calibration," submitted to the Empirical Software Engineering and Measurement Conference, 2008 (pdf)
Building cost estimation models is often considered as a search problem in which the solver should return an optimal solution satisfying an objective function. Moreover, the obtained solution also needs to meet certain constraints. In the COCOMO model, for example, increasing in the estimated effort requires increases in the model parameters. In this research, we introduce a constrained regression technique that uses different objective functions and constraints for calibrating COCOMO model parameters. To access the performance of the proposed technique, we run a cross-validation procedure and compare the prediction accuracy from different approaches such as least squares, stepwise, Lasso, and Ridge regression. Our result suggests that the regression model that minimizes the mean of relative error and imposes non-negative coefficients is a favorable technique for calibrating the COCOMO model parameters.
Added April 2nd, 2008
USC-CSSE-2008-805 - WikiWinWin: A Wiki Based System for Collaborative Requirements Negotiation (Da Yang, Di Wu, Supannika Koolmanojwong, A. Winsor Brown, Barry Boehm)
Defining requirements is one of the most critical activities in the development of software intensive systems.
The EasyWinWin system has been very good in capturing initial requirements involving heterogeneous stakeholders in over 150 client-developer requirements negotiations. However, it has been less easy to use in updating requirements and related information as a project proceeds and adapting to the evolving nature of the requirements.
Because our clients are finding that wikis are easier to learn and use, and can organize information in a flexible and updatable manner, we have developed an initial version of a WikiWinWin system as a potential successor to EasyWinWin. We have conducted a case study of WikiWinWin, and the result shows that the initial WikiWinWin is basically good at facilitating stakeholder collaborative negotiation and learning, but has some limitations that we are now addressing.
Added February 22nd, 2008
USC-CSSE-2008-804 - Applying Value-Based Software Processes: An ERP Example (LiGuo Huang, Barry Boehm, Hao Hu, Jidong Ge, Jian Lü, Cheng Qian)
LiGuo Huang, Barry Boehm, Hao Hu, Jidong Ge, Jian Lü, Cheng Qian, "Applying Value-Based Software Processes: An ERP Example," to be accepted by International Journal of Software and Informatics (pdf)
Commercial organizations increasingly need software processes sensitive to business value, quick to apply, supportive of multi-stakeholder collaboration, and capable of early analysis for subprocess consistency and compatibility. This paper presents experience in applying a lightweight synthesis of a Value-Based Software Quality Achievement process and an Object-Petri-Net-based process model to achieve a stakeholder win-win outcome for software quality achievement in an on-going ERP software project in China. The application results confirmed that 1) the application of value-based approaches was inherently better than value-neutral approaches adopted by most ERP software projects; 2) the Object-Petri-Net-based process model provided project managers with a synchronization and stabilization framework for process activities, success-critical stakeholders and their value propositions; 3) process visualization and simulation tools significantly increased management visibility and controllability for the success of the software project.
Added February 22nd, 2008
USC-CSSE-2008-803 - System of Systems Lead System Integrators: Where Do They Spend Their Time and What Makes Them More or Less Efficient? (Jo Ann Lane, Barry Boehm)
Jo Ann Lane, Barry Boehm, "System of Systems Lead System Integrators: Where Do They Spend Their Time and What Makes Them More or Less Efficient?" Systems Engineering, Volume 11, Issue 1, February 2008, pp. 81-91 (pdf)
As organizations strive to expand system capabilities through the development of system-of-systems (SoS) architectures, they want to know "how much effort" and "how long". In order to answer these questions, it is important to first understand the types of activities performed in SoS architecture development and integration and how these vary across different SoS implementations. This paper provides preliminary results of research conducted to determine types of SoS Lead System Integrator (LSI) activities and how these differ from the more traditional system engineering activities described in EIA 632 (Processes for Engineering a System). It also looks at concepts in organizational theory, complex adaptive systems, and chaos theory and how these might be applied to SoS LSI activities to improve success rates and efficiency in the development of these “very large” complex systems.
Added February 22nd, 2008
USC-CSSE-2008-800 - Making a Difference in the Software Century (Barry Boehm)
Barry Boehm, "Making a Difference in the Software Century," Computer magazine, March 2008, pp. 32-38 (pdf)
I feel very lucky to have been born in the US in the 1930s and to have had a chance to participate in the formation of a whole new discipline of software engineering. I think those of you just entering the software engineering field have an even more exciting prospect ahead of you. I believe that at least the next few decades will make the 21st century the Software Century. Software will be the main element that drives our necessary capabilities and quality of life, and people who know how best to develop software-intensive systems will have the greatest opportunity to make a difference in the results.
This will be very satisfying for software engineers, but it will impose large responsibilities to provide excellence in the software-intensive systems that are developed and in the services that they provide. Here are the main challenges that I believe 21st-century software engineers will need to address: increasingly rapid change, uncertainty and emergence, dependability, diversity, and interdependence.
Added February 25th, 2008
USC-CSSE-2007-741 - The Value-Based Theory of Systems Engineering: Identifying and Explaining Dependencies (Barry Boehm, Apurva Jain)
Barry Boehm, Apurva Jain, "The Value-Based Theory of Systems Engineering: Identifying and Explaining Dependencies," INCOSE 2007, San Diego, CA, June 24-28, 2007 (pdf)
The Value-Based Theory of Systems Engineering brings together many interdisciplinary theoretical lenses into a state of synchrony and allows reasoning about systems in different dimensions, and at various levels of abstraction. The theory’s primary strength is in its ability to identify and work through the dependencies of most socio-political-technical systems and explain success in such contexts by situating the success-critical stakeholders at the forefront. In this paper we present the 4+1 theoretical lenses of the Value-Based Theory of Systems Engineering with a core emphasis on the Dependency Theory – the first and most complex of the four component theories.
Added July 18th, 2008
USC-CSSE-2007-740 - Developing a Process Framework Using Principles of Value-Based Software Engineering (Barry Boehm, Apurva Jain)
Barry Boehm, Apurva Jain, "Developing a Process Framework Using Principles of Value-Based Software Engineering," Software Process: Improvement and Practice, Volume 12, Issue 5, September 2007, pp. 377-385 (pdf)
In this article we present a software process framework using the 4 + 1 theory and principles of value-based software engineering (VBSE). The value-based process framework serves as a 6-step process guide, and explains critical interactions between the five theories in the 4 + 1 theory of value-based software engineering. This article also applies the process framework to a supply chain organization through a case study analysis to illustrate its strength in practice.
Added July 18th, 2008
USC-CSSE-2007-739 - Future Challenges and Rewards for Software Engineers (Barry Boehm)
Barry Boehm, "Future Challenges and Rewards for Software Engineers," DoD Software Tech News, October 2007, pp. 6-12 (pdf)
A clear trend for the future of software engineering is illustrated by Figure 1, showing the growth in percentage of aircraft requirements involving software control.
This makes software engineering skills increasingly valuable and software careers increasingly influential, but it also places significant responsibilities on software engineers to ensure that their software will be able to deliver high levels of dependability. Some additional future trends discussed below will make this goal increasingly challenging, but also increasingly important to address. These trends are: uncertainty and emergence; rapid change; multifaceted dependability; diversity; and interdependence.
Added July 16th, 2008
USC-CSSE-2007-738 - Putting Systems to Work: Processes for Expanding System Capabilities Through System of Systems Acquisitions (Barry Boehm, Jo Ann Lane)
Barry Boehm, Jo Ann Lane, "Putting Systems to Work: Processes for Expanding System Capabilities Through System of Systems Acquisitions," Symposium on Complex Systems Engineering, January 11-12, 2007 (pdf)
Business and mission pressures to provide new complex system capabilities quickly are leading organizations to pursue the development of systems of systems. This allows us to get additional “mileage” from our existing, but somewhat aging systems by putting them to work in a system of systems environment with other systems in order to achieve the new desired capabilities. Our experiences in helping to define, acquire, develop, and assess 21st century software-intensive system of systems (SISOS ) have taught us that traditional 20th century acquisition and development processes do not work well on such systems. This article summarizes the characteristics of such systems, and indicates the major problem areas in using traditional processes on them. We also present new processes that we and others have been developing, applying, and evolving to address 21st century SISOS. These include extensions to the risk-driven spiral model to cover broad (many systems), deep (many supplier levels), and long (many increments) acquisitions needing rapid fielding, high assurance, adaptability to high change traffic, and complex interactions with evolving, often complex, Commercial Off-the-Shelf (COTS) products, legacy systems, and external systems.
Added April 16th, 2008
USC-CSSE-2007-737 - A SLOC Counting Standard (Vu Nguyen, Sophia Deeds-Rubin, Thomas Tan, Barry Boehm)
Vu Nguyen, Sophia Deeds-Rubin, Thomas Tan, Barry Boehm, "A SLOC Counting Standard," COCOMO II Forum 2007 (pdf)
Source Lines of Code (SLOC or LOC) is one of the most widely used sizing metrics in industry and literature. It is the key input for most of major cost estimation models such as COCOMO, SLIM, and SEER-SEM. Although the SEI and the IEEE have established SLOC definitions and guidelines to standardize counting practice, inconsistency in SLOC measurements still exists in industry and research. This problem causes the incomparability of SLOC metric among organizations and the inaccuracy of cost estimation. This report presents a set of counting standards that defines what and how to count SLOC. Our experience with the development and use of the USC CodeCountT toolset, a popular utility that automates the SLOC counting process, suggests that this problem can be alleviated by the use of a reasonable and unambiguous counting standard guide and with the support of a configurable counting tool.
Added April 2nd, 2008
USC-CSSE-2007-736 - A Framework for Identification and Resolution of Interoperability Mismatches in COTS-Based Systems (Jesal Bhuta, Barry Boehm)
Jesal Bhuta, Barry Boehm, "A Framework for Identification and Resolution of Interoperability Mismatches in COTS-Based Systems," 2nd International Workshop on Incorporating COTS Software into Software Systems: Tools and Techniques (co-located with the 29th International Conference on Software Engineering), Minneapolis, May 2007 (pdf)
Software systems today are frequently composed from prefabricated commercial components that provide complex functionality and engage in complex interactions. Such projects that utilize multiple commercial-off-the-shelf (COTS) products often confront interoperability conflicts resulting in budget and schedule overruns. These conflicts occur because of the incompatible assumptions made by developers of these products. Identification of such conflicts and planning strategies to resolve them is critical for developing such systems under budget and schedule constraints. In this paper we present an attribute-based framework that can be used to perform high-level and automated interoperability assessment to filter out COTS product combinations whose integration will not be feasible within the project constraints. Our framework is built upon standard definitions of both COTS components and connectors and is intended for use by architects and developers during the design phase of a software system. Our preliminary experience in using the framework indicates an increase in interoperability assessment productivity by 50% and accuracy by 20%.
Jesal Bhuta, Barry Boehm, "Attribute-Based COTS Product Interoperability Assessment," International Conference on COTS-Based Software Systems, Alberta, Canada, February/March 2007 (pdf)
Software systems today are frequently composed from prefabricated commercial components that provide complex functionality and engage in complex interactions. Such projects that utilize multiple commercial-off-the-shelf (COTS) products often confront interoperability conflicts resulting in budget and schedule overruns. These conflicts occur because of the incompatible assumptions made by developers of these products. Identification of such conflicts and planning strategies to resolve them is critical for developing such systems under budget and schedule constraints. Unfortunately, acquiring information to perform interoperability analysis is a time-intensive process. Moreover, increase in the number of COTS products available to fulfill similar functionality leads to hundreds of COTS product combinations, further complicating the COTS interoperability assessment landscape. In this paper we present a set of attributes that can be used to define COTS interoperability-specific characteristics. COTS product definitions based on these attributes can be used to perform high-level and automated interoperability assessment to filter out COTS product combinations whose integration will not be feasible within project constraints. In addition to above stated attributes, we present a tool that can be used to assess COTS-based architectures for interoperability conflicts, reducing the overall effort spent in performing interoperability analysis. Our preliminary experience in using the framework indicates an increase in interoperability assessment productivity by 50% and accuracy by 20%.
Added February 22nd, 2008
USC-CSEE-2007-733 - Measuring Security Investment Benefit for Off the Shelf Software Systems - Stakeholder Value Driven Approach (Yue Chen, Barry Boehm, Luke Sheppard)
Yue Chen, Barry Boehm, Luke Sheppard, "Measuring Security Investment Benefit for Off the Shelf Software Systems - Stakeholder Value Driven Approach," The 2007 Workshop on the Economics of Information Security (WEIS 2007), CMU, PA, June 2007 (pdf)
This paper presents the Threat Modeling method based on Attacking Path Analysis (T-MAP) which quantifies security threats by calculating the total severity weights of relevant attacking paths for Commercial Off The Shelf (COTS) based systems. Compared to existing approaches, T-MAP is sensitive to an organization’s business value priorities and IT environment. It distills the technical details of thousands of relevant software vulnerabilities into management-friendly numbers at a high-level, and systematically establishes the traceability and consistency from management-level organizational value propositions to technical-level security threats and corresponding mitigation strategies. In its initial usage in a large IT organization, T-MAP has demonstrated promising strength in prioritizing and estimating security investment effectiveness, as well as in evaluating the security performance of COTS systems. In the case study, we demonstrate the steps of using T-MAP to analyze the cost-effectiveness of how system patching, user account control and firewall can improve security. In addition, we introduce a software tool that automates the T-MAP.
Added February 22nd, 2008
USC-CSSE-2007-732 - Using a Hybrid Method for Formalizing Informal Stakeholder Decisions (Hasan Kitapci, Barry Boehm)
Hasan Kitapci, Barry Boehm, "Using a Hybrid Method for Formalizing Informal Stakeholder Decisions," 40th Annual Hawaii International Conference on System Sciences (HICSS'07), 2007, p. 283 (pdf)
Decisions are hard to make when available information is incomplete, inconsistent, and ambiguous. Moreover, good – sufficiently complete, consistent, traceable, and testable – requirements are a prerequisite for successful projects. Without understanding what the stakeholders really want and need and writing these requirements in a concise, understandable and testable manner, projects will not develop what the stakeholders wanted leading to either major late rework or project termination.
During the development of the WinWin negotiation model and the EasyWinWin requirements negotiation method, we have gained considerable experience in capturing decisions made by stakeholders in over 100 projects. However, the transition from informal decisions to requirements specification is still a challenging problem.
Based on our analysis of the projects to date, we have developed an integrated set of gap-bridging methods as a hybrid method to support stakeholders making better decisions in order to eliminate requirements related problems and ease the process of formality transition.
Added February 22nd, 2008
USC-CSSE-2007-731 - A Replicate Empirical Comparison between Pair Development and Software Development with Inspection (Monvorath Phongpaibul, Barry Boehm)
Monvorath Phongpaibul, Barry Boehm, "A Replicate Empirical Comparison between Pair Development and Software Development with Inspection," ESEM 2007 (pdf)
In 2005, we studied the development effort and effect of quality comparisons between software development with Fagan’s inspection and pair development. Three experiments were conducted in Thailand: two classroom experiments and one industry experiment. We found that in the classroom experiments, the pair development group had less average development effort than the inspection group with the same or higher level of quality. The industry experiment’s result showed pair development to have a bit more effort but about 40% fewer major defects. However, since this set of experiments was conducted in Thailand, the results may be different if we conducted the experiment in other countries due to the impact of cultural differences. To investigate this we conducted another experiment with Computer Science graduate students at USC in Fall 2006. Unfortunately, the majority of the graduate students who participated in the experiment were from India, a country in which the culture is not much different from Thailand [18], [19]. As a result, we cannot compare the impact of cultural differences in this paper. However, the results showed that the experiment can be replicated in other countries where the cultures are similar.
Added February 22nd, 2008
USC-CSSE-2007-730 - Comparative Experiences with Electronic Process Guide Generator Tools (Monvarath Phongpaibul, Supannika Koolmanojwong, Alexander Lam, Barry Boehm)
Comparative Experiences with Electronic Process Guide Generator Tools (pdf)
Monvarath Phongpaibul, Supannika Koolmanojwong, Alexander Lam, Barry Boehm
The primary objective of all software engineering courses is to help students learn how to develop successful software systems with good software engineering practices. Various tools and guidelines are used to assist students to gain the knowledge as much as possible. USC’s Center for Systems and Software Engineering (CSSE) has found that the keystone course in learning software engineering is a year-long real-client team project course. Over the last ten years, CSSE has evolved a set of guidelines for the course, and has experimented with early tests for creating electronic process guides for MBASE (Model-Based (Systems) Architecting and Software Engineering) Guidelines using Spearmint/EPG. Currently, CSSE has been developing and experimenting with Eclipse Process Framework’s (EPF) to situate the LeanMBASE Guidelines. This paper reports our comparative experiences of using the earlier and current tools to generate the electronic process guidelines. In our analysis, we used the objectives defined by Humphrey and Kellner[17] to compare the process tools. The evaluation identifies some research challenges and areas for future research work.
USC-CSSE-2007-729 - An Empirical Study on MBASE and LeanMBASE (Supannika Koolmanojwong, Barry Boehm)
Supannika Koolmanojwong, Barry Boehm, "An Empirical Study on MBASE and LeanMBASE" ESEM 2007, p. 496 (pdf)
From 1998-2005, the successful Model-Based (Systems) Architecting and Software Engineering (MBASE) had been used as a set of guidelines for the keystone two-semester real-client team project graduate software engineering course sequence. However, to fit with small-sized and limited schedule projects, MBASE was trimmed to reduce the huge amount of efforts in documentation. Consequently, LeanMBASE, which is a light-weight software process framework that helps teams identify the high-value activities and helps balance the workload of a development, is being used in the software engineering course. This paper reports the comparison and improvement of the projects that use MBASE and LeanMBASE in terms of content, performance, and customer satisfaction.
Added February 22nd, 2008
USC-CSSE-2007-728 - Assessment of Process Modeling Tools to Support the Analysis of System of Systems Engineering Activities (Jo Ann Lane, F. Stan Settles, Barry Boehm)
Jo Ann Lane, F. Stan Settles, Barry Boehm, "Assessment of Process Modeling Tools to Support the Analysis of System of Systems Engineering Activities," Proceedings of the Fifth Annual Conference on Systems Engineering Research, March 2007 (pdf)
Many organizations are attempting to provide new system capabilities through the net-centric integration of existing systems into systems of systems (SoS). The engineering activities used to architect and develop these SoS are often referred to as SoS Engineering (SoSE). Recent reports are indicating that SoSE activities are considerably different from classical systems engineering (SE) activities. Other systems engineering experts believe that there is nothing really different with respect to systems engineering activities or component-based engineering in the SoS environment—that there are only differences in scale and complexity. To better understand SoSE, studies are currently underway to evaluate the differences between classical SE and SoSE. This paper summarizes process areas to be investigated in the SE-SoSE comparison and then analyzes and evaluates several types of process modeling tools in order to identify a set of tools that can be used to capture classical SE and SoSE process characteristics for further comparison.
Added February 22nd, 2008
USC-CSSE-2007-725 - System-of-Systems Cost Estimation: Analysis of Lead System Integrator Engineering Activities (Jo Ann Lane, Barry Boehm)
Jo Ann Lane, Barry Boehm, "System-of-Systems Cost Estimation: Analysis of Lead System Integrator Engineering Activities," Information Resources Management Journal, Vol. 20, No. 2, 2007 (pdf)
As organizations strive to expand system capabilities through the development of system-of-systems (SoS) architectures, they want to know "how much effort" and "how long" to implement the SoS. In order to answer these questions, it is important to first understand the types of activities performed in SoS architecture development and integration and how these vary across different SoS implementations. This paper provides results of research conducted to determine types of SoS Lead System Integrator (LSI) activities and how these differ from the more traditional system engineering activities described in Electronic Industries Alliance (EIA) 632 (“Processes for Engineering a System”). This research further analyzed effort and schedule issues on “very large” SoS programs to more clearly identify and profile the types of activities performed by the typical LSI and to determine organizational characteristics that significantly impact overall success and productivity of the LSI effort. The results of this effort have been captured in a reduced-parameter version of the Constructive SoS Integration Cost Model COSOSIMO) that estimates LSI SoS Engineering (SoSE) effort.
(This was an invited expansion of a paper that received a best paper award at the 2006 Symposium on Information Systems Research and Systems Approach that was part of the InterSymp 2006 sponsored by the International Institute for Advanced Studies in Systems Research and Cybernetics.)
Added February 22nd, 2008
USC-CSSE-2007-724 - Comparative Experiences with Software Process Modeling Tools for the Incremental Commitment Model (Supannika Koolmanojwong, Monvorath Phongpaibul, Natachart Laoteppitak, Barry Boehm)
Supannika Koolmanojwong, Monvorath Phongpaibul, Natachart Laoteppitak, Barry Boehm, "Comparative Experiences with Software Process Modeling Tools for the Incremental Commitment Model" (pdf)
The Incremental Commitment Model (ICM) is a new generation process model that focuses on the incremental growth of success critical stakeholder satisfaction, system definition and stakeholder commitment. ICM has been introduced in system engineering, but not software engineering. In the Fall 2008, ICM will be used as a process model to develop software system in the USC Software Engineering graduate course. Hence, two significantly different software process modeling tools are selected to create the electronic process guidelines for this course. This paper reports our comparative experiences between an adaptability tolerance framework, Eclipse Process Framework Composer (EPFC) and a precision oriented process definition language, Little-JIL in order to create ICM electronic guide. In addition, the paper provides a tool comparison analysis by using Humphrey and Kellner's criteria and a target group evaluative result. The evaluation identifies some research challenges and areas for future research work.
Added December 15th, 2007
USC-CSSE-2007-722 - Unifying the Software Process Spectrum (Mingshu Li, Barry Boehm, Leon J. Osterweil)
Mingshu Li, Barry Boehm, Leon J. Osterweil, "Unifying the Software Process Spectrum," Journal of Software, Vol.17, No.4, April 2006, pp. 649-657 (pdf)
Software Process Workshop (SPW 2005) was held in Beijing on May 25-27, 2005. This paper introduces the motivation of organizing such a workshop, as well as its theme and paper gathering and review; and summarizes the main content and insights of 11 keynote speeches, 30 regular papers in five sessions of “Process Content”, “Process Tools and Metrics”, “Process Management”, “Process Representation and Analysis”, and “Experience Reports”, 8 software development support tools demonstration, and the ending panel “Where Are We Now? Where Should We Go Next?”.
Added November 8th, 2007
USC-CSSE-2007-721 - A Quality-Based Cost Estimation Model for the Product Line Life Cycle (Hoh Peter In, Jongmoon Baik, Sangsoo Kim, Ye Yang, Barry Boehm)
Hoh Peter In, Jongmoon Baik, Sangsoo Kim, Ye Yang, Barry Boehm, "A Quality-Based Cost Estimation Model for the Product Line Life Cycle," Communications of The ACM, Volume 49, Number 12, December 2006 (pdf)
In reusing common organizational assets, the software product line (SPL) provides substantial business opportunities for reducing the unit cost of similar products, improving productivity, reducing time to market, and promoting customer satisfaction [4]. By adopting effective product line practices, return on investment (ROI) becomes increasingly critical in the decision-making process. The majority of SPL cost estimation
and ROI models [5-9] confine themselves to software development costs and savings. However, if software quality cost is considered in the spectrum of the SPL life cycle, product lines can result in considerably larger payoffs, compared to non-product lines.
This article proposes a quality-based product line life cycle cost estimation model, called qCOPLIMO, and investigates the effect of software quality cost on the ROI of SPL. qCOPLIMO is derived from two COCOMO suite models: COPLIMO and COQUALMO, as presented in Figure 1. COPLIMO [2] provides a baseline cost estimation model of the product line life cycle, and COQUALMO [3] estimates the number of residual defects. These models are used to estimate software quality cost. Both models are an extension of COCOMO II [1].
Added November 8th, 2007
USC-CSSE-2007-719 - The Business Case for Automated Software Engineering (Tim Menzies, Oussama Elrawas, Jairus Hihn, Martin S. Feather, Ray Madachy, Barry Boehm)
Tim Menzies, Oussama Elrawas, Jairus Hihn, Martin S. Feather, Ray Madachy, Barry Boehm, "The Business Case for Automated Software Engineering," Automated Software Engineering, Proceedings of the Twenty-Second IEEE/ACM International Conference on Automated Software Engineering, Atlanta, Georgia, USA, 2007, pp. 303-312 (pdf)
Adoption of advanced automated SE (ASE) tools would be favored if a business case could be made that these tools are more valuable than alternate methods. In theory, software prediction models can be used to make that case. In practice, this is complicated by the ”local tuning” problem. Normally, predictors for software effort and defects and threat use local data to tune their predictions. Such local tuning data is often unavailable.
This paper shows that assessing the relative merits of different SE methods need not require precise local tunings. STAR1 is a simulated annealer plus a Bayesian post-processor that explores the space of possible local tunings within software prediction models. STAR1 ranks project decisions by their effects on effort and defects and threats. In experiments with two NASA systems, STAR1 found that ASE tools were necessary to minimize effort/ defect/ threats.
Added November 8th, 2007
USC-CSSE-2007-716 - Modern Tools to Support DoD Software Intensive System of Systems Cost Estimation - A DACS State-of-the-Art Report (Jo Ann Lane, Barry Boehm)
Jo Ann Lane, Barry Boehm, "Modern Tools to Support DoD Software Intensive System of Systems Cost Estimation - A DACS State-of-the-Art Report," A DACS State-of-the-Art Report, August 2007 (pdf)
Many Department of Defense (DoD) organizations are attempting to provide new system capabilities through the net-centric integration of existing software-intensive systems into a new system often referred to as Software-Intensive System of Systems (SISOS). The goal of this approach is to build on existing capabilities to produce new capabilities not provided by the existing systems in a timely and cost-effective manner. Many of these new SISOS efforts such as the Future Combat Systems are of a size and complexity unlike their predecessor systems and cost estimation tools such as the Constructive Cost Model (COCOMO) suite are undergoing significant enhancements to address these challenges. This report describes the unique challenges of SISOS cost estimation, how current tools are changing to support these challenges, as well as on-going efforts to further support SISOS cost estimation needs. This report concentrates heavily on the COCOMO-based models and tools, but also incorporates activities underway by other cost model vendors.
Added November 1st, 2007
USC-CSSE-2007-715 - Using the Incremental Commitment Model to Integrate System Acquisition, Systems Engineering, and Software Engineering (Barry Boehm, Jo Ann Lane)
Barry Boehm, Jo Ann Lane, "Using the Incremental Commitment Model to Integrate System Acquisition, Systems Engineering, and Software Engineering," an expanded version of CrossTalk, October 2007 (pdf)
One of the top recommendations to emerge from the October 2006 Deputy Under Secretary of Defense (DUSD) Acquisition, Technology, and Logistics (AT&L) Defense Software Strategy Summit was to find ways of better integrating software engineering into the systems engineering and acquisition process. Concurrently, a National Research Council study was addressing the problem of better integrating human factors into the systems engineering and acquisition process. This paper presents a model that emerged from these and related efforts that shows promise of improving these integrations. This model, called the Incremental Commitment Model (ICM), organizes systems engineering and acquisition processes in ways that better accommodate the different strengths and difficulties of hardware, software, and human factors engineering approaches. It also provides points at which they can synchronize and stabilize, and at which their risks of going forward can be better assessed and fitted into a risk-driven stakeholder resource commitment process.
Added July 17th, 2007
USC-CSSE-2007-713 - Modeling a Value-Based Process Based On Object Petri Nets and Its Application in the ERP Domain (LiGuo Huang, Barry Boehm, Hao Hu, Jidong Ge, Jian Lü, Cheng Qian)
LiGuo Huang, Barry Boehm, Hao Hu, Jidong Ge, Jian Lü, Cheng Qian, "Modeling a Value-Based Process Based On Object Petri Nets and Its Application in the ERP Domain," International Journal of Software and Informatics, Fall 2007 (pdf)
Commercial organizations increasingly need software processes sensitive to business value, quick to apply, and capable of early analysis for subprocess consistency and compatibility. This paper presents experience in applying a lightweight synthesis of a Value-Based Software Quality Achievement (VBSQA) process and an Object-Petri-Net-based process model (called VBSQA-OPN) to achieve a manager-satisfactory process for software quality achievement in an on-going ERP software project in China. The results confirmed that 1) the application of value-based approaches was inherently better than value-neutral approaches adopted by most ERP software projects; 2) the VBSQA-OPN model provided project managers with a synchronization and stabilization framework for process activities, success-critical stakeholders and their value propositions; 3) process visualization and simulation tools significantly increased management visibility and controllability for the success of software project.
Added July 4th, 2007
USC-CSSE-2007-712 - Using the Incremental Commitment Model to Integrate System Acquisition, Systems Engineering, and Software Engineering (Barry Boehm, Jo Ann Lane)
Barry Boehm, Jo Ann Lane, "Using the Incremental Commitment Model to Integrate System Acquisition, Systems Engineering, and Software Engineering," CrossTalk Journal, Volume 20, Number 10, 2007 (pdf)
One of the top recommendations to emerge from the October 2006 Deputy Under Secretary of Defense (DUSD) Acquisition, Technology, and Logistics (AT&L) Defense Software Strategy Summit was to find ways of better integrating software engineering into the systems engineering and acquisition process. Concurrently, a National Research Council study was addressing the problem of better integrating human factors into the systems engineering and acquisition process. This paper presents a model that emerged from these and related efforts that shows promise of improving these integrations. This model, called the Incremental Commitment Model (ICM), organizes systems engineering and acquisition processes in ways that better accommodate the different strengths and difficulties of hardware, software, and human factors engineering approaches. It also provides points at which they can synchronize and stabilize, and at which their risks of going forward can be better assessed and fitted into a risk-driven stakeholder resource commitment process.
Added July 4th, 2007
USC-CSEE-2007-711 - Stakeholder Value Driven Threat Modeling for Off The Shelf Based Systems (Yue Chen, Barry Boehm)
Yue Chen, Barry Boehm, "Stakeholder Value Driven Threat Modeling for Off The Shelf Based Systems," The 29th International Conference on Software Engineering (ICSE), Doctoral Symposium, Minneapolis, MN, May 2007 (pdf)
As the trend of the usage of third party Commercial-Off-The-Shelf (COTS) and open source software continuously increases, COTS security has become a major concern for many organizations whose daily business extensively relies upon a healthy IT infrastructure. But, according to the 2006 CSI/FBI computer criminal survey, 47% of the surveyed organizations only spent no more than 2% of the IT budget in security. Often, competing with limited IT resources and the fast changing internet threats, the ability to prioritize security vulnerabilities and address them efficiently has become a critical success factor for every security manager.
As known, the security impacts of vulnerabilities can be specified in terms of Confidentiality, Integrity, and Availability (CIA). These attributes can have very different business indications in different context. Unfortunately, most current leading vulnerability rating systems by CERT, Microsoft, NIST, and Symantec are value neutral, static, and treat CIA equally. To date, it is still very difficult to prioritize security vulnerability efficiently with quantitative evidence because of lack of effective metrics and historical data, and the complex and sensitive nature of security.
We propose to (1) establish a framework, namely the Threat Modeling method based on Attacking Path Analysis (T-MAP),which is sensitive to stakeholder value propositions to dynamically prioritize COTS vulnerability and model security threat; (2) grow a comprehensive COTS vulnerability database that supports T-MAP; (3) automate T-MAP with a XML framework that abstracts the process.
Added February 22nd, 2008
USC-CSSE-2007-710 - Using the Incremental Commitment Model to Achieve Successful System Development (Barry Boehm, Jo Ann Lane)
Barry Boehm, Jo Ann Lane, "Using the Incremental Commitment Model to Achieve Successful System Development" (pdf)
Studies to evaluate the usage and success of the spiral development model have shown mixed results—many successes but many misinterpretations and neglect of its underlying principles, leading to continuing development problems and failed systems. This article describes a recent improvement to the spiral development process model that is easier to understand, is harder to misinterpret, and better enables integration of the human, hardware, and software aspects of a software-intensive system’s development and evolution. This model, called the Incremental Commitment Model (ICM), embodies the principles underlying the spiral model, but organizes its process into multiple views (including a spiral view) that are more straightforward to apply and better aligned with mainstream system acquisition phases and milestones.
Added May 7th, 2007
USC-CSSE-2007-708 - Measuring Security Investment Benefit for Off the Shelf Software Systems - A Stakeholder Value Driven Approach (Yue Chen, Barry Boehm, Luke Sheppard)
Yue Chen, Barry Boehm, Luke Sheppard, "Measuring Security Investment Benefit for Off the Shelf Software Systems - A Stakeholder Value Driven Approach," The Sixth Workshop on the Economics of Information Security (WEIS 2007) (pdf)
This paper presents the Threat Modeling method based on Attacking Path Analysis (T-MAP) which quantifies security threats by calculating the total severity weights of relevant attacking paths for Commercial Off The Shelf (COTS) based systems. Compared to existing approaches, T-MAP is sensitive to an organization’s business value priorities and IT environment. It distills the technical details of thousands of relevant software vulnerabilities into management-friendly numbers at a high-level. In its initial usage in a large IT organization, T-MAP has demonstrated significant strength in prioritizing and estimating security investment effectiveness, as well as in evaluating the security performance of COTS systems. In the case study, we demonstrate the steps of using T-MAP to analyze the cost-effectiveness of how system patching, user account control and firewall can improve security. In addition, we introduce a software tool that automates the T-MAP.
Added May 4th, 2007
USC-CSSE-2007-705 - Assessment of Process Modeling Tools to Support the Analysis of System of Systems Engineering Activities (Jo Ann Lane, F. Stan Settles, Barry Boehm)
Jo Ann Lane, F. Stan Settles, Barry Boehm, "Assessment of Process Modeling Tools to Support the Analysis of System of Systems Engineering Activities," Conference on Systems Engineering Research (CSER) (pdf)
Many organizations are attempting to provide new system capabilities through the net-centric integration of existing systems into systems of systems (SoS). The engineering activities used to architect and develop these SoS are often referred to as SoS Engineering (SoSE). Recent reports are indicating that SoSE activities are considerably different from classical systems engineering (SE) activities. Other systems engineering experts believe that there is nothing really different with respect to systems engineering activities or component-based engineering in the SoS environment-that there are only differences in scale and complexity. To better understand SoSE, studies are currently underway to evaluate the differences between classical SE and SoSE. This paper summarizes process areas to be investigated in the SE-SoSE comparison and then analyzes and evaluates several types of process modeling tools in order to identify a set of tools that can be used to capture classical SE and SoSE process characteristics for further comparison.
Added March 23th, 2007
USC-CSSE-2007-700 - Coping with the Cone of Uncertainty: An Empirical Study of the SAIV Process Model (Da Yang, Barry Boehm, Ye Yang, Qing Wang, Mingshu Li)
There is large uncertainty with the software cost in the early stages of software development due to requirement volatility, incomplete understanding of product domain, reuse opportunities, market change, etc. This makes it an increasingly challenging issue to deliver software on time, within budget, and with satisfactory quality in the IT field. In this paper, we introduce the Schedule as Independent Variable (SAIV) approach, and present the empirical study of how it is used to cope with the uncertainty of cost, and deliver customer satisfactory products in 8 USC (University of Southern California) projects. We also investigate the success factors and best practices in managing the uncertainty of cost.
Added February 22nd, 2008
USC-CSSE-2006-632 - A Theory and Process for Relazing Successful Systems (Barry Boehm)
Barry Boehm, "A Theory and Process for Relazing Successful Systems," INSIGHT INCOSE, Volume 8, Issue 2, March 2006, pp. 11-12 (pdf)
Three key themes in the INCOSE Technical Vision [Crisp et. al., 2005] are:
• The INCOSE definition of Systems Engineering as "an interdisciplinary approach and means to enable the realization of successful systems."
• The objective of providing an underlying theory of systems engineering.
• The objective of determining the distinguishing intellectual content of systems engineering as compared to other engineering disciplines.
The paper introduces the essentials of an initial underlying theory of systems engineering. Its Fundamental System Success Theorem provides necessary and sufficient conditions for a system to be successful. These conditions involve determining and reconciling the value propositions of the system's success-critical stakeholders. Their elaboration leads to a System Success Realization Theorem, and a process that involves other components of the theory. These include utility theory, dependency theory, decision theory, and control theory. Their emphasis on stakeholder value provides a key distinction between system engineering's concern with stakeholder values and the essentially value-neutral orientation of other engineering disciplines.
Added July 25th, 2008
USC-CSSE-2006-631 - Towards a Work Breakdown Structure for Net Centric System of Systems Engineering and Management (Gan Wang, Jo Ann Lane, Ricardo Valerdi, Barry Boehm)
Gan Wang, Jo Ann Lane, Ricardo Valerdi, Barry Boehm, "Towards a Work Breakdown Structure for Net Centric System of Systems Engineering and Management," 16th INCOSE Symposium, Orlando, FL, July 2006 (pdf)
As the system engineering industry sees an increasing focus on the lifecycle development, acquisition, and sustainment of net-centric Systems of Systems (SoS) and Family of Systems (FoS), organizations find the need to evolve current processes and tools to better handle the increased scope, scale, and complexity of these efforts. One such tool, the Work Breakdown Structure (WBS) is important in planning and execution of program activities as requirements and goals of the program evolve. This paper provides an overview of the limitations of current WBSs with respect to SoS efforts and presents a proposed WBS structure that more adequately reflects the evolving processes and cross-organizational complexities.
Added May 12th, 2008
USC-CSSE-2006-630 - The WinWin Approach: Using a Requirements Negotiation Tool for Rationale Capture and Use (Barry Boehm, Hasan Kitapci)
Barry Boehm, Hasan Kitapci, "The WinWin Approach: Using a Requirements Negotiation Tool for Rationale Capture and Use," Rationale Management in Software Engineering, Springer Berlin / Heidelberg, Part 2, 2000, pp. 173-190 (pdf)
A highly cost-effective approach for rationale capture and management is to provide automated support, and capture the resulting artifacts of the process by which software and system requirements and solutions are negotiated. The WinWin process model, equilibrium model, and collaborative negotiation tool provide capabilities for capturing the artifacts. The MBASE software process model provides an approach for using and updating the rationale artifacts and process to keep it in a win-win state. Supporting requirements negotiation with attaching rationale can have a high impact on all phases of development by enabling much better context for change impact analysis as the increasingly frequent requirements changes arrive. The WinWin approach involves having a system's success-critical stakeholders participate in a negotiation process so they can converge on a mutually satisfactory or win-win set of requirements. The WinWin framework in essence captures stakeholder-oriented objectives, options and constraints in the form of a decision rationale.
Added April 29th, 2008
USC-CSSE-2006-629 - A Value-Based Software Process Framework (Barry Boehm, Apurva Jain)
Barry Boehm, Apurva Jain, "A Value-Based Software Process Framework," Lecture Notes in Computer Science, Springer Berlin / Heidelberg, Volume 3966/2006, pp. 1-10 (pdf)
This paper presents a value-based software process framework that has been derived from the 4+1 theory of value-based software engineering (VBSE). The value-based process framework integrates the four component theories – dependency, utility, decision, and control, to the central theory W, and orients itself as a 7-step process guide to practice value-based software engineering. We also illustrate applying the process framework to a supply chain organization through a case study analysis.
Added April 21st, 2008
USC-CSSE-2006-628 - Evolving an Experience Base for Software Process Research (Zhihao Chen, Daniel Port, Yue Chen, Barry Boehm)
Zhihao Chen, Daniel Port, Yue Chen, Barry Boehm, "Evolving an Experience Base for Software Process Research," Lecture Notes in Computer Science, Springer Berlin / Heidelberg, Volume 3840/2006, pp. 433-448 (pdf)
Since 1996 the USC Center for Software Engineering has been accumulating a large amount of software process experience through many real-client project software engineering practices. Through the application of the Experience Factory approach, we have collected and evolved this experience into an experience base (eBASE) which has been leveraged successfully for empirically based software process research. Through eBASE we have realized tangible benefits in automating, organizational learning, and strategic advantages for software engineering research. We share our rationale for creating and evolving eBASE, give examples of how the eBASE has been used in recent process research, discuss current limitations and challenges with eBASE, and what we hope to do achieve in the future with it.
Added April 16th, 2008
USC-CSSE-2006-627 - Spiral Lifecycle Increment Modeling for New Hybrid Processes (Raymond Madachy, Barry Boehm, Jo Ann Lane)
Raymond Madachy, Barry Boehm, Jo Ann Lane, "Spiral Lifecycle Increment Modeling for New Hybrid Processes," Lecture Notes in Computer Science, Springer Berlin / Heidelberg, Volume 3966/2006, pp. 167-177 (pdf)
The spiral lifecycle is being extended to address new challenges for Software-Intensive Systems of Systems (SISOS), such as coping with rapid change while simultaneously assuring high dependability. A hybrid plan-driven and agile process has been outlined to address these conflicting challenges with the need to rapidly field incremental capabilities. A system dynamics model has been developed to assess the incremental hybrid process and support project decision-making. It estimates cost and schedule for multiple increments of a hybrid process that uses three specialized teams. It considers changes due to external volatility and feedback from user-driven change requests, and dynamically re-estimates and allocates resources in response to the volatility. Deferral policies and team sizes can be experimented with, and it includes tradeoff functions between cost and the timing of changes within and across increments, length of deferral delays, and others. Both the hybrid process and simulation model are being evolved on a very large scale incremental project and other potential pilots.
Added April 16th, 2008
USC-CSSE-2006-626 - A View of 20th and 21st Century Software Engineering (Barry Boehm)
George Santayana's statement,"Those who cannot remember the past are condemned to repeat it," is only half true. The past also includes successful histories. If you haven't been made aware of them, you're often condemned not to repeat their successes.
In a rapidly expanding field such as software engineering, this happens a lot. Extensive studies of many software projects such as the Standish Reports offer convincing evidence that many projects fail to repeat past successes.
This paper tries to identify at least some of the major past software experiences that were well worth repeating, and some that were not. It also tries to identify underlying phenomena influencing the evolution of software engineering practices that have at least helped the author appreciate how our field has gotten to where it has been and where it is.
A counterpart Santayana-like statement about the past and future might say,"In an era of rapid change, those who repeat the past are condemned to a bleak future." (Think about the dinosaurs, and think carefully about software engineering maturity models that emphasize repeatability.)
This paper also tries to identify some of the major sources of change that will affect software engineering practices in the next couple of decades, and identifies some strategies for assessing and adapting to these sources of change. It also makes some first steps towards distinguishing relatively timeless software engineering principles that are risky not to repeat, and conditions of change under which aging practices will become increasingly risky to repeat.
Added November 9th, 2007
USC-CSSE-2006-625 - Providing Incentives for Spiral Developments: An Award Fee Plan (Donald J. Reifer, Barry Boehm)
Donald J. Reifer, Barry Boehm, "Providing Incentives for Spiral Developments: An Award Fee Plan," Defense Journal, Supplemental Issue, Volume 12, Number 1, 2006 (pdf)
This article describes a set of award fee criteria and an award fee process and plan that enable buyers to provide suppliers with incentives for using evolutionary acquisition and spiral development approaches when developing large-scale, softwareintensive systems per DoD Directive 5000.1 and DoD Instruction 5000.2. Most Senior Program Managers agree that spiral development is a good idea. However, many quickly become confused when trying to provide contractual incentives for large system acquisitions. To reduce confusion, the authors have developed an award fee plan that Program Managers can use to stimulate on budget, schedule and technical performance by supplier teams who are pursuing system development and deployment under contract to the government or a Lead System Integrator.
Added November 9th, 2007
USC-CSSE-2006-624 - Using a Hybrid Method for Formalizing Informal Stakeholder Requirements Inputs (Hasan Kitapci, Barry Boehm)
Hasan Kitapci, Barry Boehm, "Using a Hybrid Method for Formalizing Informal Stakeholder Requirements Inputs," Software Process Improvement and Practice, Wiley, 2007 (pdf)
Success of software development depends on the quality of the requirements specification. Moreover, good – sufficiently complete, consistent, traceable, and testable – requirements are a prerequisite for later activities of the development project. Without understanding what the stakeholders really want and need, and writing these requirements, projects will not develop what the stakeholders wanted.
During the development of the WinWin negotiation model and the EasyWinWin requirements negotiation method, we have gained considerable experience in capturing informal requirements in over 100 projects. However, the transition from informal representations to semi-formal and formal representations is still a challenging problem.
Based on our analysis of the projects to date, we have developed an integrated set of gap-bridging methods as a hybrid method to formalize informal stakeholder requirements inputs. The basic idea is that orchestrating these gap-bridging methods through the requirements engineering process can significantly eliminate requirements related problems and ease the process of formality transition.
Added December 19th, 2006
USC-CSSE-2006-623 - Assessing Hybrid Incremental Processes for SISOS Development (Raymond Madachy, Barry Boehm, Jo Ann Lane)
Raymond Madachy, Barry Boehm, Jo Ann Lane, "Assessing Hybrid Incremental Processes for SISOS Development," Software Process Improvement and Practice, Wiley, 2007 (pdf)
New processes are being assessed to address modern challenges for Software-Intensive Systems of Systems (SISOS), such as coping with rapid change while simultaneously assuring high dependability. A hybrid agile and plan-driven process based on the spiral lifecycle has been outlined to address these conflicting challenges with the need to rapidly field incremental capabilities in a value-based framework. A system dynamics model has been developed to assess the incremental hybrid process and support project decision-making. It estimates cost and schedule for multiple increments of a hybrid process that uses three specialized teams, and also considers the mission value of software capabilities. It considers changes due to external volatility and feedback from user-driven change requests, and dynamically re-estimates and allocates resources in response to the volatility. Deferral policies and team sizes can be experimented with, and it includes tradeoff functions between cost and the timing of changes within and across increments, length of deferral delays, and others. We illustrate how the model can be used to determine optimal agile team size to handle changes. Both the hybrid process and simulation model are being evolved on a very large scale incremental SISOS project and other potential pilots.
Added December 19th, 2006
USC-CSE-2006-619 - A Value-Based Theory of Systems Engineering (Barry Boehm, Apurva Jain)
Barry Boehm, Apurva Jain, "A Value-Based Theory of Systems Engineering," Proceedings, INCOSE 2006 (pdf)
The INCOSE definition of "systems engineering" is "an interdisciplinary approach and means to enable the realization of successful systems." The Value-Based Theory of Systems Engineering presents necessary and sufficient conditions for realizing a successful system and elaborates them into an executable process. The theory and process are illustrated on a supply-chain system example, and evaluated with respect to criteria for a good theory.
Added April 16, 2008
USC-CSE-2006-616 - Comparison and Assessment of Cost Models for NASA Flight Projects (Ray Madachy, Barry Boehm, Dan Wu)
Ray Madachy, Barry Boehm, Dan Wu, "Comparison and Assessment of Cost Models for NASA Flight Projects," 21st International Forum on COCOMO and Software Cost Modeling (pdf)
This research is assessing the strengths, limitations, and improvement needs of existing cost, schedule, quality and risk models for critical flight software for the NASA AMES project Software Risk Advisory Tools. This particular report focuses only on the cost model aspect and supersedes the cost model sections in a previously delivered draft report [USC-CSE 2006].
A comparative survey and analysis of cost models used by NASA flight projects is described. The models include COCOMO II, SEER-SEM and True S. We look at evidence of accuracy, the need for calibration, and the use of knowledge bases to reflect specific domain factors. The models are assessed against a common database of relevant NASA projects. The overriding primary focus is on flight projects, but part of the work also looks at related sub-domains for critical NASA software. They are assessed as applicable in some of the following analyses. This report also addresses the critical NASA domain factors of high reliability and high complexity, and how the cost models address them.
Added October 28th, 2006
USC-CSE-2006-615 - A Framework for the Assessment and Selection on Software Compononents and Connectors in COTS-Based Architectures (Jesal Bhuta, Chris A. Mattmann, Nenad Medvidovic, Barry Boehm)
Jesal Bhuta, Chris A. Mattmann, Nenad Medvidovic, Barry Boehm, "A Framework for the Assessment and Selection on Software Compononents and Connectors in COTS-Based Architectures," Sixth Working IEEE/IFIP Conference on Software Architecture, Mumbai, India (pdf)
Software systems today are composed from prefabricated commercial components and connectors that provide complex functionality and engage in complex interactions. Unfortunately, because of the distinct assumptions made by developers of these products, successfully integrating them into a software system can be complicated, often causing budget and schedule overruns. A number of integration risks can often be resolved by selecting the 'right' set of COTS components and connectors that can be integrated with minimal effort. In this paper we describe a framework for selecting COTS software components and connectors ensuring their interoperability in software-intensive systems. Our framework is built upon standard definitions of both COTS components and connectors and is intended for use by architects and developers during the design phase of a software system. We highlight the utility of our framework using a challenging example from the data-intensive systems domain. Our preliminary experience in using the framework indicates an increase in interoperability assessment productivity by 50% and accuracy by 20%.
Added September 19th, 2006
USC-CSE-2006-614 - System-of-Systems Cost Estimation: Analysis of Lead System Integrator Engineering Activities (Jo Ann Lane, Barry Boehm)
Jo Ann Lane, Barry Boehm, "System-of-Systems Cost Estimation: Analysis of Lead System Integrator Engineering Activities," Inter-Symposium 2006, The International Institute for Advanced Studies in Systems Research and Cybernetics (pdf)
As organizations strive to expand system capabilities through the development of system-of-systems (SoS) architectures, they want to know "how much effort" and "how long" to implement the SoS. In order to answer these questions, it is important to first understand the types of activities performed in SoS architecture development and integration and how these vary across different SoS implementations. This paper provides results of research conducted to determine types of SoS Lead System Integrator (LSI) activities and how these differ from the more traditional system engineering activities described in Electronic Industries Alliance (EIA) 632 (“Processes for Engineering a System”). This research further analyzed effort and schedule issues on “very large” SoS programs to more clearly identify and profile the types of activities performed by the typical LSI and to determine organizational characteristics that significantly impact overall success and productivity of the LSI effort. The results of this effort have been captured in a reduced-parameter version of the Constructive SoS Integration Cost Model (COSOSIMO) that estimates LSI SoS Engineering (SoSE) effort.
Added September 19th, 2006
USC-CSE-2006-613 - 21st Century Processes for Acquiring 21st Century Software-Intensive Systems of Systems (Barry Boehm, Jo Ann Lane)
Barry Boehm, Jo Ann Lane, "21st Century Processes for Acquiring 21st Century Software-Intensive Systems of Systems," CrossTalk, May 2006 (pdf)
Our experiences in helping to define, acquire, develop, and assess 21st century software-intensive system of systems (SISOS) have taught us that traditional 20th century acquisition and development processes do not work well on such systems. This article summarizes the characteristics of such systems, and indicates the major problem areas in using traditional processes on them. We also present new processes that we and others have been developing, applying, and evolving to address 21st century SISOS. These include extensions to the risk-driven spiral model to cover broad (many systems), deep (many supplier levels), and long (many increments) acquisitions needing rapid fielding, high assurance, adaptability to high change traffic, and complex interactions with evolving Commercial Off-the-Shelf (COTS) products, legacy systems, and external systems.
Added September 19th, 2006
USC-CSE-2006-611 - Synthesis of Existing Cost Models to Meet System of Systems Needs (Jo Ann Lane, Barry Boehm)
Jo Ann Lane, Barry Boehm, "Synthesis of Existing Cost Models to Meet System of Systems Needs," Proceedings of Conference on Systems Engineering Research (CSER), 2006 (pdf)
Today’s need for more complex, more capable systems in a short timeframe is leading more organizations towards the integration of existing systems into network-centric, knowledge-based system-of-systems (SoS). Software and system cost model tools to date have focused on the software and system development activities of a single software system, but none to date adequately estimate the integration of multiple systems into an SoS. This paper presents an overview of the activities that must be included in an SoS cost model and describes an approach for estimating SoS effort using the Constructive Cost Model (COCOMO) suite of estimation tools to estimate SoS Lead System Integrator (LSI) effort as well as the total SoS development effort.
Added September 19th, 2006
USC-CSE-2006-609 - Measuring Security Investment Benefit for COTS Based Systems - A Stakeholder Value Driven Approach (Yue Chen, Barry Boehm, Luke Sheppard)
Yue Chen, Barry Boehm, Luke Sheppard, "Measuring Security Investment Benefit for COTS Based Systems - A Stakeholder Value Driven Approach," 29th International Conference on Software Engineering, September 8th, 2006 (pdf)
This paper presents the improved version of the Threat Modeling method based on Attacking Path Analysis (T-MAP) which quantifies security threats by calculating the total severity weights of relevant attacking paths for Commercial Off The Shelf (COTS) based systems.
Added September 9th, 2006
USC-CSE-2006-607 - Value Driven Security Threat Modeling Based on Attacking Path Analysis (Yue Chen, Barry Boehm, Luke Sheppard)
Yue Chen, Barry Boehm, Luke Sheppard, "Value Driven Security Threat Modeling Based on Attacking Path Analysis," 40th Hawaii International Conference on System Sciences, June 15, 2006 (pdf)
Security threat modeling has been an important but difficult topic. This paper presents a novel quantitative threat modeling method, the Threat Modeling method based on Attacking Path Analysis (T-MAP), which quantifies security threats by calculating the total severity weights of relevant attacking paths for Commercial Off The Shelf (COTS) systems. Compared to existing approaches, T-MAP is sensitive to an organization's business value priorities and IT environment. It distills the technical details of thousands of software vulnerabilities into management-friendly numbers at a high-level. T-MAP can help system designers evaluate the security performance of COTS systems and analyze the effectiveness of security practices. In the case study, we demonstrate the steps of using T-MAP to analyze the cost-effectiveness of how IT system patching and upgrades can improve security. In addition, we introduce a software tool that automates the T-MAP framework.
Added May 11th, 2006
USC-CSE-2006-603 - Some Future Trends And Implications for Systems And Software Engineering Processes (Barry Boehm)
Barry Boehm, "Some Future Trends And Implications for Systems And Software Engineering Processes," Systems Engineering, Wiley Periodicals, Inc., Volume 9, Issue 1, 2006, pp. 1-19 (pdf)
In response to the increasing criticality of software within systems and the increasing demands being put onto 21st century systems, systems and software engineering processes will evolve significantly over the next two decades. This paper identifies eight relatively surprise-free trends - the increasing interaction of software engineering and systems engineering; increased emphasis on users and end value; increased emphasis on systems and software dependability; increasingly rapid change; increasing global connectivity and need for systems to interoperate; increasingly complex systems of systems; increasing needs for COTS, reuse, and legacy systems and software integration; and computational plenty. It also identifies two wild card trends: increasing software autonomy and combinations of biology and computing. It then discusses the likely influences of these trends on systems and software engineering processes between now and 2025, and presents an emerging scalable spiral process model for coping with the resulting challenges and opportunities of developing 21st century software-intensive systems and systems of systems.
Added May 8th, 2006
USC-CSE-2006-600 - Cost Estimation for Secure Software & Systems (Ed Colbert, Dan Wu, Yue Chen, Barry Boehm)
Ed Colbert, Dan Wu, Yue Chen, Barry Boehm, "Cost Estimation for Secure Software & Systems," accepted at ISPA 2006 (pdf)
The Center for Software Engineering (CSE) at the University of Southern California (USC) is extending the widely–used Constructive Cost Model version 2 (COCOMO II) [Boehm, Abts, et al. 2000] to account for developing secure software. CSE is also developing a model for estimating the cost to acquire secure systems, and is evaluating the effect of security goals on other models in the COCOMO family. We will present the work to date.
Added January 16th, 2006
USC-CSE-2005-521 - Vic Basili's Experience Base Papers (Barry Boehm)
It's impossible to discuss a piece of Vic's work without relating it to the other pieces. Everything fits together within an overall strategy of applying the empirical scientific method to the challenge of continuously improving an organization's software processes and products.
The Goal-Question-Metric approach recognizes that "improvement" requires metrics, but that every organization has its own set of goals and environmental influences. This means that "improvement" metrics may be anything from meaningless to dysfunctional if they aren't related to the organization's goals and to questions about the organization's current state and evolving environment. The Quality Improvement Paradigm recognizes that continuous process and product improvement needs to fit within a framework involving the scientific method of hypothesis formulation, test, and closed-loop feedback control. The Experience Factory recognizes that continuous improvement, as with any other investment to achieve results, should have a business plan, management commitment to the plan, and an infrastructure of policies, processes, procedures, facilities, tools, management information systems, stafEng, training, and incentives to get best results. The Sohare Engineering Laboratory (SEL) has been a marvelous example of successfUlly applying, evaluating, learning about, and evolving all of these concepts and capabilities in the area of software development and evolution. It justly deserved being the first recipient of the IEEE Software Process Achievement Award.
In this context, a narrow definition of an Experience Base is that it serves as the management information system for the continuous process and product improvement enterprise. This includes the data definitions, data base organization and content, database management capabilities, and analysis tools for formulating, testing, and evolving hypotheses about improving the organization's processes and products. But I think a broader definition is more appropriate; the entire infrastructure of product, process, data, and personnel assets that evolve to enable the organization to most rapidly and costeffectively improve its capabilities to adapt to its changing goals and environment
Added July 18th, 2008
USC-CSE-2005-520 - Effect of Schedule Compression on Project Effort (Ye Yang, Zhihao Chen, Ricardo Valerdi, Barry Boehm)
Ye Yang, Zhihao Chen, Ricardo Valerdi, Barry Boehm, "Effect of Schedule Compression on Project Effort," 27th Conference of the International Society of Parametric Analysts, Denver, CO, June 2005 (pdf)
Schedule pressure is often faced by project managers and software developers who want to quickly deploy information systems. Typical strategies to compress project time scales might include adding more staff/personnel, investing in development tools, improving hardware, or improving development methods. The tradeoff between cost, schedule, and performance is one of the most important analyses performed during the planning stages of software development projects. In order to adequately compare the effects of these three constraints on the project it is essential to understand their individual influence on the project’s outcome.
In this paper, we present an investigation into the effect of schedule compression on software project development effort and cost and show that people are generally optimistic when estimating the amount of schedule compression. This paper is divided into three sections. First, we follow the Ideal Effort Multiplier (IEM) analysis on the SCED cost driver of the COCOMO II model. Second, compare the real schedule compression ratio exhibited by 161 industry projects and the ratio represented by the SCED cost driver. Finally, based on the above analysis, a set of newly proposed SCED driver ratings for COCOMO II are introduced which show an improvement of 6% in the model estimating accuracy.
Added December 11th, 2005
USC-CSE-2005-518 - SimVBSE: Developing a Game for Value-Based Software Engineering (Apurva Jain, Barry Boehm)
Apurva Jain, Barry Boehm, "SimVBSE: Developing a Game for Value-Based Software Engineering," submitted to CSEET 2006 (pdf)
The development of games in aid of improving and enriching a student's learning experience is again on the rise. The beer game [6] in the field of system dynamics was developed to instill the key principles of production and distribution. SimSE [5] provides a simulated game for its players to take on the role of a project manager, and experience the fundamentals of software engineering through cause-effect models. In this paper we present an initial design of SimVBSE as a game for students to better understand value-based software engineering [1] , and its underlying theory [3] .
Added November 15th, 2005
USC-CSE-2005-517 - Finding the Right Data for Software Cost Modeling (Zhihao Chen, Tim Menzies, Dan Port, Barry Boehm)
Zhihao Chen, Tim Menzies, Dan Port, Barry Boehm, "Finding the Right Data for Software Cost Modeling," IEEE Software, Volume 22, Issue 6, November-December 2005, pp. 38-46 (pdf)
Strange to say, when building a software cost model, sometimes it's useful to ignore much of the available cost data. One way to do this is to perform data-pruning experiments after data collection and before model building. Experiments involving a set of Unix scripts that employ a variable-subtraction algorithm from the WEKA (Waikato Environment for Knowledge Analysis) data-mining toolkit illustrate this approach's effectiveness. This article is part of a special issue on predictor modeling.
Added November 11th, 2005
USC-CSE-2005-516 - Management Challenges to Implementing Agile Processes in Traditional Development Organizations (Barry Boehm, Rich Turner)
Barry Boehm, Rich Turner, "Management Challenges to Implementing Agile Processes in Traditional Development Organizations," IEEE Software, Volume 22, Issue 5, September-October 2005, pp. 30-39 (pdf)
Discussions with traditional developers and managers concerning agile software development practices nearly always contain two somewhat contradictory ideas. They find that on small, stand-alone projects, agile practices are less burdensome and more in tune with the software industry's increasing needs for rapid development and coping with continuous change. Managers face several barriers, real and perceived, when they try to bring agile approaches into traditional organizations. They categorized the barriers either as problems only in terms of scope or scale, or as significant general issues needing resolution. From these two categories, we've identified three areas - development process conflicts, business process conflicts, and people conflicts - that we believe are the critical challenges to software managers of large organizations in bringing agile approaches to bear in their projects.
Added November 11th, 2005
USC-CSE-2005-515 - Value-Based Processes for COTS-Based Applications (Ye Yang, Jesal Bhuta, Barry Boehm, Dan Port)
Value-Based Processes for COTS-Based Applications (pdf)
Ye Yang, Jesal Bhuta, Barry Boehm, Dan Port
Economic imperatives are changing the nature of software development processes to reflect both the opportunities and challenges of using COTS products. Processes are increasingly moving away from the time-consuming composition of custom software from lines of code (although these processes still apply for developing the COTS products themselves) toward assessment, tailoring, and integration of COTS or other reusable components. Two factors are driving this change: COTS or other reusable components can provide significant user capabilities within limited costs and development time, and more COTS products are becoming available to provide needed user functions.
USC-CSE-2005-514 - Assessing COTS Integration Risk Using Cost Estimation Inputs (Ye Yang, Barry Boehm, Betsy Clark)
Ye Yang, Barry Boehm, Betsy Clark, "Assessing COTS Integration Risk Using Cost Estimation Inputs," International Conference on Software Engineering, Proceedings of the 28th international conference on Software engineering, 2006, pp. 431-438 (pdf)
Most risk analysis tools and techniques require the user to enter a good deal of information before they can provide useful diagnoses. In this paper, we describe an approach to enable the user to obtain a COTS glue code integration risk analysis with no inputs other than the set of glue code cost drivers the user submits to get a glue code integration effort estimate with the COnstructive COTS integration cost estimation (COCOTS) tool. The risk assessment approach is built on a knowledge base with 24 risk identification rules and a 3-level risk probability weighting scheme obtained from an expert Delphi analysis. Each risk rule is defined as one critical combination of two COCOTS cost drivers that may cause certain undesired outcome if they are both rated at their worst case ratings. The 3-level nonlinear risk weighting scheme represents the relative probability of risk occurring with respect to the individual cost driver ratings from the input. Further, to determine the relative risk impact, we use the productivity range of each cost driver in the risky combination to reflect the cost consequence of risk occurring. We also develop a prototype called COCOTS Risk Analyzer to automate our risk assessment method. The evaluation of our approach shows that it has done an effective job of estimating the relative risk levels of both small USC e-services and large industry COTS-based applications.
Added November 11th, 2005
USC-CSE-2005-513 - Achievements and Challenges in Software Resources Estimation (Barry Boehm, Ricardo Valerdi)
Achievements and Challenges in Software Resources Estimation (pdf)
Barry Boehm, Ricardo Valerdi
This paper summarizes major achievements and challenges of software resource estimation over the last forty years. We address critical issues that enabled major achievements such as the development of good model forms, criteria for evaluating models, methods for integrating expert judgment and statistical data analysis, and processes for developing new models that cover new software development approaches. Future trends in software development and evolution processes are projected, along with their implications and challenges for future software resource estimation capabilities.
Submitted to ICSE 2006
Added November 11th, 2005
USC-CSE-2005-512 - Empirical Results from an Experiment on Value-Based Review (VBR) Processes (Keun Lee, Barry Boehm)
Keun Lee, Barry Boehm, "Empirical Results from an Experiment on Value-Based Review (VBR)," Processes, ISESE 2005 (pdf)
As part of our research on value-based software engineering, we conducted an experiment on the use of value-based review (VBR) processes. We developed a set of VBR checklists with issues ranked by successcriticality, and a set of VBR processes prioritized by issue criticality and stakeholder-negotiated product capability priorities. The experiment involved 28 independent verification and validation (IV&V) subjects (full-time working professionals taking a distance learning course) reviewing specifications produced by 18 real-client, full-time student e-services projects. The IV&V subjects were randomly assigned to use either the VBR approach or our previous valueneutral checklist-based reading (CBR) approach. The difference between groups was not statistically significant for number of issues reported, but was statistically significant for number of issues per review hour, total issue impact, and cost effectiveness in terms of total issue impact per review hour. For the latter, the VBRs were roughly twice as cost-effective as the CBRs.
Added November 11th, 2005
USC-CSE-2005-511 - Value-based Feedback in Software and Information Systems Development (LiGuo Huang, Barry Boehm)
LiGuo Huang, Barry Boehm, "Value-based Feedback in Software and Information Systems Development, Software Evolution and Feedback (pdf)
The role of feedback control in software and information system development has traditionally focused on a milestone plan to deliver a pre-specified set of capabilities within a negotiated budget and schedule. One of the most powerful approaches available for controlling traditional software projects is called the Earned Value system. However, the Earned Value Management process is generally good for tracking whether a project is meeting its original plan. It becomes difficult to administer if the project plans change rapidly. And more significantly it has absolutely nothing to say about the actual value being earned for the organization by the results of the project.
This chapter begins by summering a set of four nested feedback and feedforward loops that have been successfully used to scope, estimate, control, and improve the predictability and efficiency of software development and evolution. It then proposes an alternative approach for project feedback control. It focuses on the actual stakeholder value likely to be earned by completing the project. And a framework is provided for monitoring and controlling value in terms of a Benefits Realization Approach [Thorp, 1998] and business case analysis. An order processing system is used as an example to illustrate the value-based feedback control mechanisms. At the end of this chapter, it presents the conclusions and directions for future research and development.
Added November 11th, 2005
USC-CSE-2005-510 - How Much Software Quality Investment is Enough: A Value-Based Approach (LiGuo Huang, Barry Boehm)
LiGuo Huang, Barry Boehm, "How Much Software Quality Investment is Enough: A Value-Based Approach," IEEE Software, Volume 23, Number 5, September/October 2006, pp. 88-95 (pdf)
A classical problem facing many software projects is how to determine when to stop testing and release the product for use. We have found that risk analysis helps to address such "how much is enough?" questions, by balancing the risk exposure of doing too little with the risk exposure of doing too much. However, people have often found it difficult to quantify the relative probabilities and sizes of loss in order to provide practical approaches for determining a risk-balanced "sweet spot" operating point.
We provide a quantitative approach based on the COCOMO II cost estimation model and the COQUALMO quality estimation model to help project decision-makers determine "how much software quality investment is enough?" We also provide examples of its use under differing value profiles. Further, we use the models and some representative empirical data to assess the relative payoff of value-based testing as compared to value-neutral testing.
Added November 10th, 2005
USC-CSE-2005-509 - COCOMO Suite Methodology and Evolution (Barry Boehm, Ricardo Valerdi, Jo Ann Lane, A. Winsor Brown)
Barry Boehm, Ricardo Valerdi, Jo Ann Lane, A. Winsor Brown, "COCOMO Suite Methodology and Evolution," CrossTalk, April 2005 (pdf)
Over the years, software managers and software engineers have used various cost models such as the Constructive Cost Model (COCOMO) to support their software cost and estimation processes. These models have also helped them to reason about the cost and schedule implications of their development decisions, investment decisions, client negotiations and requested changes, risk management decisions, and process improvement decisions. Since that time, COCOMO has cultivated a user community that has contributed to its development and calibration. COCOMO has also evolved to meet user needs as the scope and complexity of software system development has grown. This eventually led to the current version of the model: COCOMO II.2000.3. The growing need for the model to estimate different aspects of software development served as a catalyst for the creation of derivative models and extensions that could better address commercial off-the-shelf software integration, system engineering, and system-of-systems architecting and engineering. This article presents an overview of the models in the COCOMO suite that includes extensions and independent models, and describes the underlying methodologies and the logic behind the models and how they can be used together to support larger software system estimation needs. It concludes with a discussion of the latest University of Southern California Center for Software Engineering effort to unify these various models into a single, comprehensive, user-friendly tool.
Added November 10th, 2005
USC-CSE-2005-507 - The Future of Software and Systems Engineering Processes (Barry Boehm)
Barry Boehm, "The Future of Software and Systems Engineering Processes," SSCI Member Forum, 2005 (pdf)
In response to the increasing criticality of software within systems and the increasing demands being put onto software-intensive systems, software and systems engineering processes will evolve significantly over the next two decades. This paper identifies eight relatively surprise-free trends - the increasing interaction of software engineering and systems engineering; increased emphasis on users and end value; increasing software criticality and need for dependability; increased emphasis on systems and software dependability; increasingly rapid change; increasing global connectivity and need for systems to interoperate; increasing IT globalization and need for interoperability; increasingly complex systems of systems; increasing needs for COTS, reuse, and legacy systems and software integration; and computational plenty. It also identifies two "wild card" trends: in-creasing software autonomy and combinations of biology and computing. It then discusses the likely influences of these trends on software and systems engineering processes between now and 2025, and presents an emerging three-team adaptive process model for coping with the resulting challenges and opportunities of developing 21st century software-intensive systems and systems of systems.
Added June 29th, 2005
USC-CSE-2005-505 - An Initial Theory of Value-Based Software Engineering (Barry Boehm, Apurva Jain)
This chapter presents an initial “4+1” theory of value-based software engineering (VBSE). The engine in the center is the stakeholder win-win Theory W, which addresses the questions of “which values are important?” and “how is success assured?” for a given software engineering enterprise. The four additional theories that it draws upon are utility theory (how important are the values?), decision theory (how do stakeholders’ values determine decisions?), dependency theory (how do dependencies affect value realization?), and control theory (how to adapt to change and control value realization?). After discussing the motivation and context for developing a VBSE theory and the criteria for a good theory, the chapter discusses how the theories work together into a process for defining, developing, and evolving software-intensive systems. It also illustrates the application of the theory to a supply chain system example, discusses how well the theory meets the criteria for a good theory, and identifies an agenda for further research.
Added March 31st, 2005
USC-CSE-2005-504 - Value-Based Software Engineering: Overview and Agenda (Barry Boehm)
Much of current software engineering practice and research is done in a value-neutral setting, in which every requirement, use case, object, test case, and defect is equally important. However most studies of the critical success factors distinguishing successful from failed software projects find that the primary critical success factors lie in the value domain.
The value-based software engineering (VBSE) agenda discussed in this chapter and exemplified in the other chapters involves integrating value considerations into the full range of existing and emerging software engineering principles and practices. The chapter then summarized the primary components of the agenda: value-based requirements engineering, architecting, design and development, verification and validation, planning and control, risk management, quality management, people management, and an underlying theory of VBSE. It concludes by approaches for going toward VBSE at the project, organization, national, or global level.
Added March 31st, 2005
USC-CSE-2005-503 - Value-Based Software Engineering: Seven Key Elements and Ethical Considerations (Barry Boehm)
Barry Boehm, "Value-Based Software Engineering: Seven Key Elements and Ethical Considerations," Value-Based Software Engineering, Springer Berlin Heidelberg, Part 2, 2006, pp. 109-132 (pdf)
This chapter presents seven key elements that provide candidate foundations for value-based software engineering:
1. Benefits Realization Analysis
2. Stakeholder Value Proposition Elicitation and Reconciliation
3. Business Case Analysis
4. Continuous Risk and Opportunity Management
5. Concurrent System and Software Engineering
6. Value-Based Monitoring and Control
7. Change as Opportunity
Using a case study, it then shows how some of these elements can be used to incorporate ethical considerations into daily software engineering practice.
Added March 31st, 2005
USC-CSE-2005-502 - Value-Based Verification and Validation Guidelines (Keun Lee, Monvorath Phongpaibul, Barry Boehm)
Keun Lee, Monvorath Phongpaibul, Barry Boehm, "Value-Based Verification and Validation Guidelines" (pdf)
The USC Center for Software Engineering’s Value-Based Software Engineering agenda involves experimentation with value-based reformulations of traditional value-neutral software engineering methods. The experimentation explores conditions under which value-based methods lead to more cost-effective project outcomes, and assesses the degree of impact that value-based methods have on the various dimensions of project outcomes. Examples of areas in which value-based technical have shown improvements in cost-effectiveness have included stakeholder win-win requirements determination, use of value-based anchor point milestones, use of prioritized requirements to support schedule-as-independent variable development processes, and the use of risk management and business case analysis to support value-based project monitoring and control.
Added March 31st, 2005
USC-CSE-2005-500 - Software Process Disruptors, Opportunity Areas, and Strategies (Barry Boehm)
Barry Boehm, "Software Process Disruptors, Opportunity Areas, and Strategies," (pdf)
The near future (5-10 years) of software processes will be largely driven by disruptive forces that require organizations to change their traditional ways of doing business. This report begins with a discussion of the major current and near-future disruptors in the software process area and how they interact. It then discusses major trends in terms of opportunity areas for dealing with various combinations of disruptors. Based on the opportunity areas, it then identifies some attractive future strategies that appear to have high payoff.
Added January 6th, 2005
USC-CSE-2004-519 - The Schedule as Independent Variable (SAIV) Process for Acquisition Software-Intensive Systems (Barry Boehm, A. Winsor Brown, LiGuo Huang, Dan Port)
Barry Boehm, A. Winsor Brown, LiGuo Huang, Dan Port, "The Schedule as Independent Variable (SAIV) Process for Acquisition Software-Intensive Systems," Proceedings, INCOSE 2004, July 2004 (pdf)
Barry Boehm, A. Winsor Brown, LiGuo Huang, Dan Port
In this article, we show how you can use the MBASE process framework to generate a family of acquisition process models for delivering user-satisfactory systems under schedule, cost, and quality constraints. We present the six major steps of the Schedule/Cost/Schedule-Cost-Quality as Independent Variable (SAIV/CAIV/SCQAIV) process using SAIV and a representative Department of Defense (DoD) Command, Control, and Communications Interoperability application as context. We then summarize our experience in using SAIV on 26 University of Southern California electronic services projects, followed by discussions of SAIV/CAIV/SCQAIV application in the commercial and defense sectors, of model application within the DoD acquisition framework, and of the resulting conclusions.
Added November 14th, 2005
USC-CSE-2004-518 - Using Empirical Testbeds to Accelerate Technology Maturity and Transition: The SCRover Experience (Barry Boehm, Jesal Bhuta, David Garlan, Eric Gradman, LiGuo Huang, Alexander Lam, Ray Madachy, Nenad Medvidovic, Kenneth Meyer, Steven Meyers, Gustavo Perez, Kirk Reinholtz, Roshanak Roshandel, Nicolas Rouquette)
Barry Boehm, Jesal Bhuta, David Garlan, Eric Gradman, LiGuo Huang, Alexander Lam, Ray Madachy, Nenad Medvidovic, Kenneth Meyer, Steven Meyers, Gustavo Perez, Kirk Reinholtz, Roshanak Roshandel, Nicolas Rouquette, "Using Empirical Testbeds to Accelerate Technology Maturity and Transition: The SCRover Experience," Proceedings of the 2004 International Symposium on Empirical Software Engineering, ISESE'04, August 19-20 2004, pp. 117-126 (pdf)
This paper is an experience report on a first attempt to develop and apply a new form of software: a full-service empirical testbed designed to evaluate alternative software dependability technologies, and to accelerate their maturation and transition into project use. The SCRover testbed includes not only the specifications, code, and hardware of a public safety robot, but also the package of instrumentation, scenario drivers, seeded defects, experimentation guidelines, and comparative effort and defect data needed to facilitate technology evaluation experiments.
The SCRover testbed's initial operational capability has been recently applied to empirically evaluate two architecture definition languages (ADLs) and toolsets, Mae and AcmeStudio. The testbed evaluation showed (1) that the ADL-based toolsets were complementary and cost-effective to apply to mission-critical systems; (2) that the testbed was cost-effective to use by researchers; and (3) that collaboration in testbed use by researchers and the Jet Propulsion Laboratory (JPL) project users resulted in actions to accelerate technology maturity and transition into project use. The evaluation also identified a number of lessons learned for improving the SCRover testbed, and for development and application of future technology evaluation testbeds.
Added November 14th, 2005
USC-CSE-2004-517 - A Software Product Line Life Cycle Cost Estimation Model (Barry Boehm, A. Winsor Brown, Ray Madachy, Ye Yang)
Barry Boehm, A. Winsor Brown, Ray Madachy, Ye Yang, "A Software Product Line Life Cycle Cost Estimation Model," Proceedings of the 2004 International Symposium on Empirical Software Engineering, ISESE'04, August 19-20 2004, pp. 156-164 (pdf)
Most software product line cost estimation models are calibrated only to local product line data rather than to a broad range of product lines. They also underestimate the return on investment for product lines by focusing only on development vs. life-cycle savings, and by applying writing-for-reuse surcharges to the entire product rather that to the portions of the product being reused. This paper offers some insights based on the exploratory development and collaborative refinement of a software product line life cycle economics model, the Constructive Product Line Investment Model (COPLIMO) that addresses these shortfalls. COPLIMO consists of two components: a product line development cost model and an annualized post-development life cycle extension. It focuses on modeling the portions of the software that involve product-specific newly-built software, fully reused black-box product line components, and product line components that are reused with adaptation. This model is an extension built upon USC-CSE's well-calibrated, multi-parameter Constructive Cost Model (COCOMO) II, tailored down to cover the essentials of strategic software product line decision issues and available supporting data from industries.
Added November 14th, 2005
USC-CSE-2004-516 - COTS-Based Systems - Twelve Lessons Learned about Maintenance (Donald J. Reifer, Victor R. Basili, Barry Boehm, Betsy Clark)
Donald J. Reifer, Victor R. Basili, Barry Boehm, Betsy Clark, "COTS-Based Systems - Twelve Lessons Learned about Maintenance," ICCBSS 2004 (pdf)
This paper presents the twelve most significant lessons the CeBASE community has learned across a wide variety of projects, domains, and organizations about COTS-Based Systems (CBS) maintenance. Because many of the lessons identified are not intuitive, the source and implications of the lesson are discussed as well within the context of maintenance model for CBS.
Added November 14th, 2005
USC-CSE-2004-515 - Spiral Acquisition of Software-Intensive Systems of Systems (Barry Boehm, A. Winsor Brown, Victor R. Basili, Rich Turner)
Barry Boehm, A. Winsor Brown, Victor R. Basili, Rich Turner, "Spiral Acquisition of Software-Intensive Systems of Systems," CrossTalk, May 2004 (pdf)
The Department of Defense and other organizations are finding that the acquisition and evolution of complex systems of systems is both software-intensive and fraught with old and new sources of risk. This article summarizes both old and new sources of risk encountered in acquiring and developing complex software-intensive systems of systems. It shows how these risks can be addressed via risk analysis, risk management planning and control, and application of the risk-driven Win-Win Spiral Model. It will also discuss techniques for handling complicating factors such as compound risks, incremental development, and rapid change, and illustrates the use of principles and practices with experience in applying the model to the U.S. Army Future Combat Systems program and similar programs.
Added November 14th, 2005
USC-CSE-2004-514 - The ROI of software dependability: The iDAVE model (Barry Boehm, LiGuo Huang, Apurva Jain, Ray Madachy)
Barry Boehm, LiGuo Huang, Apurva Jain, Ray Madachy, "The ROI of software dependability: The iDAVE model," IEEE Software, Volume 21, Issue 3, May-June 2004, pp. 54-61 (pdf)
In most organizations, proposed investments in software dependability compete for limited resources with proposed investments in software and system functionality, response time, adaptability, speed of development, ease of use, and other system capabilities. The lack of good return-on-investment models for software dependability makes determining the overall business case for dependability investments difficult. So, with a weak business case, investments in software dependability and the resulting system dependability are frequently inadequate.
Because different stakeholders depend on different system capabilities (such as availability, safety, or security) in different situations, the business case for dependability must deal with multiple situation-dependent attribute values. Dependability models will need to support stakeholders in determining their desired levels for each dependability attribute and estimating the cost, value, and ROI for achieving those. At the University of Southern California, researchers have developed software cost- and quality-estimation models and value-based software engineering processes, methods, and tools. We used these models and the value-based approach to develop an Information Dependability Attribute Value Estimation model (iDAVE) for reasoning about software dependability's ROI.
Added November 14th, 2005
USC-CSE-2004-511 - An Empirical Study of eServices Product UML Sizing Metrics (Yue Chen, Barry Boehm, Ray Madachy, Ricardo Valerdi)
Yue Chen, Barry Boehm, Ray Madachy, Ricardo Valerdi, "An Empirical Study of eServices Product UML Sizing Metrics," ACM-IEEE International Symposium on Empirical Software Engineering (ISESE), August, 2004 (pdf)
Size is one of the most fundamental measurements of software. For the past two decades, the source line of code (SLOC) and function point (FP) metrics have been dominating software sizing approaches. However both approaches have significant defects. For example, SLOCcan only be counted when the software construction is complete, while the FP counting is time consuming, expensive, and subjective. In the late 1990s researchers have been exploring faster, cheaper, and more effective sizing methods, such as Unified Modeling Language (UML) based software sizing. In this paper we present an empirical 14-project-study of three different sizing metrics which cover different software life-cycle activities: requirement metrics (requirement), UML metrics (architecture), and SLOC metrics (implementation). Our results show that the software size in terms of SLOC was moderately well correlated with the number of external use cases and the number of classes. We also demonstrate that the number of sequence diagram steps per external use case is a possible complexity indicator of software size. However, we conclude that at least for this 14-project eServices applications sample, the UML-based metrics were insufficiently well-defined and codified to serve as precise sizing metrics.
Added November 15th, 2004
USC-CSE-2004-502 - Guidelines for Producing COTS Assessment Background, Process, and Report Documents (Ye Yang, Barry Boehm)
Ye Yang, Barry Boehm, "Guidelines for Producing COTS Assessment Background, Process, and Report Documents" (pdf)
The Guidelines for Producing COTS Assessment Background, Process, and Report Documents (CAB, CAP, and CAR) apply to projects that need to assess the relative merits of commercial-off-the-shelf (COTS), nondevelopmental-item (NDI), and/or other pre-existing software products/components for use in a software system.
Basically, COTS/NDI assessment activity takes place in the following two primary situations: As part of the software process for a COTS-based development project that follows general guidelines such as Dynamic Systems Development Method (DSDM), Feature Driven Development (FDD), Model-Based Architecting and Software Engineering (MBASE), Rational Unified Process (RUP), or Team Software Process (TSP); As a standalone COTS/NDI assessment activity to serve as the basis for future project decisions.
The guidelines cover the above two primary situations and were developed by integrating COTS-based development lessons learned and proven engineering practices to help teams prepare, plan, manage, track, and improve their COTS assessment activity.
Barry Boehm, "Value-Based Software Engineering," ACM SIGSOFT Software Engineering Notes, Volume 28, Issue 2, March 2003 (pdf)
Much of current software engineering practice and research is done in a value-neutral setting, in which every requirement, use case, object, and defect is treated as equally important; methods are presented and practiced as largely logical activities; and a “separation of concerns” is practiced, in which the responsibility of software engineers is confined to turning software requirements into verified code. In earlier times, when software decisions had relatively minor influences on a system’s cost, schedule, and value, the value-neutral approach was reasonably workable. But today and increasingly in the future, software has a major influence on most systems’ cost, schedule, and value; and value-neutral software decisions can seriously degrade project outcomes.
This paper presents an agenda for a discipline of Value-Based Software Engineering. It accepts the challenge of integrating value considerations into all of the existing and emerging software engineering principles and practices, and of developing an overall framework in which they compatibly reinforce each other. Example elements of this agenda include value-based requirements engineering, architecting, design and development, verification and validation, planning and control, risk management, quality management, and people management. It presents seven key elements that provide candidate foundations for value-based software engineering: Benefits Realization Analysis; Stakeholder Value Proposition Elicitation and Reconciliation; Business Case Analysis; Continuous Risk and Opportunity Management; Concurrent System and Software Engineering; Value-Based Monitoring and Control; and Change as Opportunity.
Added July 18th, 2008
USC-CSE-2003-512 - Value-Based Software Engineering: Reinventing "Earned Value" Monitoring and Control (Barry Boehm, LiGuo Huang)
Barry Boehm, LiGuo Huang, "Value-Based Software Engineering: Reinventing "Earned Value" Monitoring and Control," ACM SIGSOFT Software Engineering Notes, Volume 28, Issue 2, March 2003 (pdf)
The Value-Based Software Engineering (VBSE) agenda described in the preceding article has the objectives of integrating value considerations into current and emerging software engineering principles and practices, and of developing an overall framework in which they compatibly reinforce each other. In this paper, we provide a case study illustrating some of the key VBSE practices, and focusing on a particular anomaly in the monitoring and control area: the “Earned Value Management System”. This is a most useful technique for monitoring and controlling the cost, schedule, and progress of a complex project. But it has absolutely nothing to say about the stakeholder value of the system being developed. The paper introduces an example order-processing software project, and shows how the use of Benefits Realization Analysis, stakeholder value proposition elicitation and reconciliation, and business case analysis provides a framework for stakeholder-earned-value monitoring and control.
Added July 18th, 2008
USC-CSE-2003-511 - Model Contract/Subcontract Award Fee Plan (Donald J. Reifer, Barry Boehm)
Donald J. Reifer, Barry Boehm, "Composable Process Elements for Developing COTS-Based Applications" (pdf, doc)
This model Award Fee Plan below has been developed by USC to provide a means to reward contractors/subcontractors for using modern software engineering techniques on large software-intensive development efforts. It identifies the following seven critical success factors for successful contractor/subcontractor performance:
1. Schedule preservation
2. Continuous integration support
3. Cost containment
4. Technical performance
5. Architecture and COTS compatibility
6. Program management
7. Risk management
This plan provides candidate evaluation scales and weights for assessing relative contractor/subcontractor performance on the seven factors. It also provides a set of candidate operating procedures for the subcontractor evaluation and award fee process. It is not a plug-and-play instrument. Instead, the plan intends to provide buyers of systems with large software content with a tailorable contractual instrument that accommodates various sources of subcontract variation.
The terms “buyer” and “supplier” are used throughout the document to convey respective roles and responsibility of the parties to this agreement. The “buyer” refers to the organization contracting or subcontracting work to a “supplier” organization. It is not meant to refer to the contracting officer who is responsible for managing the contract/subcontract terms and conditions. The term “Lead System Integrator (LSI)” is used to identify the organization assigned primary integration responsibilities for the system.
Added April 22nd, 2008
USC-CSE-2003-520 - Composable Process Elements for Developing COTS-Based Applications (Barry Boehm, Dan Port, Ye Yang, Jesal Bhuta, Chris Abts)
Barry Boehm, Dan Port, Ye Yang, Jesal Bhuta, Chris Abts, "Composable Process Elements for Developing COTS-Based Applications," Proceedings, ISESE 2003, September/October 2003 (pdf)
Data collected from five years of developing e-service applications at USC-CSE reveals that an increasing fraction have been commercial-off-the-shelf (COTS)-Based Application (CBA) projects: from 28% in 1997 to 60% in 2001. Data from both small and large CBA projects show that CBA effort is primarily distributed among the three activities of COTS assessment, COTS tailoring, and glue code development and integration, with wide variations in their distribution across projects. We have developed a set of data-motivated composable process elements, in terms of these three activities, for developing CBA's as well an overall decision framework for applying the process elements. We present data regarding the movement towards CBA's and effort distribution among them; we then proceed to describe the decision framework and to present a real-world example showing how it operates within the WinWin Spiral process model generator to orchestrate, execute, and adapt the process elements to changing project circumstances.
Added June 24th, 2004
USC-CSE-2003-519 - Reasoning About the Value of Dependability: The iDave Model (Barry Boehm, LiGuo Huang, Apurva Jain)
Barry Boehm, LiGuo Huang, Apurva Jain, "Reasoning About the Value of Dependability: The iDave Model," EDSER-5 Proceedings, May 2003 (pdf)
In this paper, we present a framework for reasoning about the value of information processing dependability investments called the Information Dependability Attribute Value Enhancement (iDAVE) model. We describe the overall structure of iDAVE, and illustrate its use in determining the ROI of investments in dependability for a commercial order processing system. We conclude that dynamic and adaptive value-based dependability mechanisms such as iDAVE model will become increasingly important provided evidence that dependability attribute requirement levels tend to be more emergent than pre-specifiable.
Added June 24th, 2004
USC-CSE-2003-518 - Agility Through Discipline: A Debate (Barry Boehm, Kent Beck)
Barry Boehm, Kent Beck, "Agility Through Discipline: A Debate," Computer, June 2003, pp. 44-46 (pdf)
Kent says: There are those who see agility in software development as a tradeoff, a sort of shaving of the wing spars. By giving up safety or rigor or accountability, we can go faster. From inside Extreme Programming, though, “agility or safety” or “agility or discipline” look like false dichotomies. From inside Extreme Programming, it seems that the only way to achieve the results we seek is to view the world in “both-and” terms instead of “either-or” terms. Why this disconnect?
Added June 24th, 2004
USC-CSE-2003-517 - People Factors in Software Management: Lessons From Comparing Agile and Plan-Driven Methods (Barry Boehm, Rich Turner)
Barry Boehm, Rich Turner, "People Factors in Software Management: Lessons From Comparing Agile and Plan-Driven Methods," Crosstalk: The Journal of Defense Software Engineering, 16 (12), December 2003, pp. 4-8 (pdf, doc)
While methodologies, management techniques, and technical approaches are valuable, a study of agile and plan-driven approaches has confirmed that the most critical success factors are much more likely to be in the realm of people factors. This paper discusses five areas where people issues can have a significant impact: staffing, culture, values, communications, and expectations management.
Added December 15th, 2003
USC-CSE-2003-513 - The Schedule as Independent Variable (SAIV) Process for Acquisition of Software-Intensive Systems (Barry Boehm, A. Winsor Brown, LiGuo Huang, Dan Port)
Barry Boehm, A. Winsor Brown, LiGuo Huang, Dan Port, "The Schedule as Independent Variable (SAIV) Process for Acquisition of Software-Intensive Systems," INCOSE 2004 International Symposium (pdf, doc)
Many system acquisitions do not achieve on-time delivery because of delays in software development. This paper presents a highly successful approach for on-time delivery of software-intensive systems: the Schedule As Independent Variable (SAIV) process. The SAIV process involves prioritization of desired features; scoping a Core Capability of top-priority features easily achievable within the available schedule; architecting for ease of dropping or adding borderline-priority features; monitoring progress with respect to plans; and adding or dropping borderline-priority features to meet the schedule target. The paper summarizes experiences and discusses critical success factors in applying the SAIV acquisition process across a range from small in-house e-services projects to very large Government systems of systems.
Added November 19th, 2003
USC-CSE-2003-507 - Using Testbeds to Accelerate Technology Maturity and Transition: The SCRover Experience (Barry Boehm, Jesal Bhuta, David Garlan, Eric Gradman, LiGuo Huang, Alexander Lam, Ray Madachy, Nenad Medvidovic, Kenneth Meyer, Steven Meyers, Gustavo Perez, Kirk Reinholtz, Roshanak Roshandel, Nicolas Rouquette)
Barry Boehm, Jesal Bhuta, David Garlan, Eric Gradman, LiGuo Huang, Alexander Lam, Ray Madachy, Nenad Medvidovic, Kenneth Meyer, Steven Meyers, Gustavo Perez, Kirk Reinholtz, Roshanak Roshandel, Nicolas Rouquette, "Using Testbeds to Accelerate Technology Maturity and Transition: The SCRover Experience," 2004 ACM-IEEE International Symposium on Empirical Software Engineering, Redondo Beach, CA, August 2004 (pdf)
This paper is an experience report on a first attempt to develop and apply a new form of software: a full service testbed designed to evaluate alternative software dependability technologies, and to accelerate their maturation and transition into project use. The SCRover testbed includes not only the specifications, code, and hardware of a public safety robot, but also the package of instrumentation, scenario drivers, seeded defects, experimentation guidelines, and comparative effort and defect data needed to facilitate technology evaluation experiments.
The SCRover testbed’s initial operational capability has been recently applied to evaluate two architecture definition languages (ADLs) and toolsets, Mae and AcmeStudio. The testbed evaluation showed (1) that the ADL-based toolsets were complementary and cost effective to apply to mission-critical systems; (2) that the testbed was cost-effective to use by researchers; and (3) that collaboration in testbed use by researchers and the Jet Propulsion Laboratory (JPL) project users resulted in actions to accelerate technology maturity and transition into project use. The evaluation also identified a number of lessons learned for improving the SCRover testbed, and for development and application of future technology evaluation testbeds.
Added September 18th, 2003
USC-CSE-2003-505 - Value-Based Software Engineering: A Case Study (Barry Boehm, LiGuo Huang)
Barry Boehm, LiGuo Huang, "Value-Based Software Engineering: A Case Study," IEEE Computer, Volume 36, Number 3, March 2003 (pdf)
The value-based approach to software development integrates value considerations into current and emerging software engineering principles and practices, while developing an overall framework in which these techniques compatibly reinforce each other.
Added April 26th, 2003
USC-CSE-2003-502 - Estimating the Cost of Security for COTS Software (Donald J. Reifer, Barry Boehm, Murali Gangadharan)
Donald J. Reifer, Barry Boehm, Murali Gangadharan, "Estimating the Cost of Security for COTS Software," Proceedings of 2nd International Conference on COTS-Based Software Systems, February 2003 (pdf)
This paper describes enhancements being made to the University of Southern California's COnstructive COTS (COCOTS) integration cost model to address security concerns. The paper starts by summarizing the actions we have taken to enhance COCOMO II to model the impact of security on development effort and duration. It then relates the COCOMO II approach to the COCOTS estimating framework so that the enhancements proposed can be incorporated into the COCOTS model. After summarizing the team's progress in developing counterpart COCOTS security cost drivers and expert-consensus cost driver parameter values, the paper points to the steps that will be taken to validate the findings and calibrate the model.
Added February 28th, 2003
USC-CSE-2003-501 - Not All CBS Are Created Equally: COTS-Intensive Project Types (Barry Boehm, Dan Port, Ye Yang, Jesal Bhuta)
Barry Boehm, Dan Port, Ye Yang, Jesal Bhuta, "Not All CBS Are Created Equally: COTS-Intensive Project Types," Proceedings of 2nd International Conference on COTS-Based Software Systems, February 2003 (pdf)
COTS products affect development strategies and tactics, but not all CBS development efforts are equal. Based on our experiences with 20 large government and industry CBS projects assessed during our development of the COCOTS estimation model, and our hands-on experience with 52 small e-services CBS projects within USC's graduate level software engineering course, we have identified four distinct CBS activity areas: assessment intensive, tailoring intensive, glue-code intensive, and non-COTS intensive. The CBS activity type fundamentally affects the COTS related activity effort and project risks. In this work we define the three COTS activity intensive CBS types and discuss their strategic comparisons based on an empirical study of the spectrum of large and small CBS projects.
Added February 28th, 2003
USC-CSE-2002-515 - The Agile Methods Fray (Tom DeMarco, Barry Boehm)
Tom DeMarco, Barry Boehm, "The Agile Methods Fray," Computer, June 2002, pp. 90-92 (pdf)
In Computer’s January 2002 issue, Barry Boehm presented a fresh look at a set of software development methods often referred to as agile or extreme programming (“Get Ready for Agile Methods, with Care,” Jan. 2002, pp. 64-69). This favorable assessment by one of the software establishment’s leading lights prompted the latest of several e-mail dialogues between Boehm and software luminary Tom DeMarco, who strongly advocates that the software establishment begin moving toward agile methods.
Added June 24th, 2004
USC-CSE-2002-514 - Disaggregating and Calibrating the CASE Tool Variable in COCOMO II (Barry Boehm, Bert Steece, Jongmoon Baik)
Barry Boehm, Bert Steece, Jongmoon Baik, "Disaggregating and Calibrating the CASE Tool Variable in COCOMO II," IEEE Transactions on Software Engineering, Volume 28, Issue 11, November 2002, pp. 1009-1022 (pdf)
Software systems of today are frequently composed from prefabricated, heterogeneous components that provide complex functionality and engage in complex interactions. Software architecture research has revealed the importance of component interactions on our ability to perform software composition. Various development organizations have found interaction mismatches to be both difficult and a core issue behind failed software integration efforts. This paper is aimed at improving the understanding of component interactions, embodied in the notion of software connectors, in order to prevent such failures. Our previous work has resulted in a four-level classification framework for studying the characteristics of connectors. This paper presents a comprehensive taxonomy of software connectors based on the previously published connector classification framework. This taxonomy is used to explain various existing software connectors and study compatibility of connector characteristics, intended to prevent component interaction mismatches.
Added June 24th, 2004
USC-CSE-2002-513 - Get Ready for Agile Methods, with Care (Barry Boehm)
Barry Boehm, "Get Ready for Agile Methods, with Care," Computer, January 2002, pp. 64-69 (pdf)
Software systems of today are frequently composed from prefabricated, heterogeneous components that provide complex functionality and engage in complex interactions. Software architecture research has revealed the importance of component interactions on our ability to perform software composition. Various development organizations have found interaction mismatches to be both difficult and a core issue behind failed software integration efforts. This paper is aimed at improving the understanding of component interactions, embodied in the notion of software connectors, in order to prevent such failures. Our previous work has resulted in a four-level classification framework for studying the characteristics of connectors. This paper presents a comprehensive taxonomy of software connectors based on the previously published connector classification framework. This taxonomy is used to explain various existing software connectors and study compatibility of connector characteristics, intended to prevent component interaction mismatches.
Added June 24th, 2004
USC-CSE-2002-512 - Using The Spiral Model and MBASE to Generate New Acquisition Process Models: SAIV, CAIV, and SCQAIV (Barry Boehm, Dan Port, LiGuo Huang, Winsor Brown)
Barry Boehm, Dan Port, LiGuo Huang, Winsor Brown, "Using The Spiral Model and MBASE to Generate New Acquisition Process Models: SAIV, CAIV, and SCQAIV," CrossTalk, January 2002, pp. 20-25 (pdf)
In this article, we show how you can use the MBASE process framework to generate a family of acquisition process models for delivering user-satisfactory systems under schedule, cost, and quality constraints. We present the six major steps of the Schedule/Cost/Schedule-Cost-Quality as Independent Variable (SAIV/CAIV/SCQAIV) process using SAIV and a representative Department of Defense (DoD) Command, Control, and Communications Interoperability application as context. We then summarize our experience in using SAIV on 26 University of Southern California electronic services projects, followed by discussions of SAIV/CAIV/SCQAIV application in the commercial and defense sectors, of model application within the DoD acquisition framework, and of the resulting conclusions.
Added June 24th, 2004
USC-CSE-2002-503 - Realizing the Benefits of the CMMI with the CeBASE Method (Barry Boehm, Dan Port, Victor Basili)
Barry Boehm, Dan Port, Victor Basili, "Realizing the Benefits of the CMMI with the CeBASE Method" (pdf)
Future systems will be increasingly software-intensive, but the type of software development they will need is not well covered by current development and maturity models such as the waterfall model and Software Capability Maturity Model development of software-intensive systems will need situation-specific balancing of discipline and flexibility to address such issues as COTS, open source, distribution, mobility rapid change, agents, collaboration support, and simultaneous achievement of rapid development and high dependability. This paper shows how the CMMI's integration of modern systems engineering, software engineering, and integrated process and product development concepts provides a framework for redressing the shortfalls of the Software CMM, and for enabling projects and organizations to achieve the right balance of discipline and flexibility for their particular situations. But the CMMI has shortfalls of its own. It provides little guidance on how to define and execute specific processes for a specific project or organization. The paper summarizes various process model generators for software intensive systems such as the spiral, the Rational Unified Process (RUP), MBASE, and the CeBASE Method. It concludes that the CeBASE Method best covers the full range of concerns in the CMMI, resolves its practice-focus shortfalls, and covers additional best practices not in the CMMI, such as business case analysis, requirements prioritization, and evolution requirements.
Added May 23rd, 2002
USC-CSE-2002-502 - Achieving CMMI Level 5 Improvements with MBASE and the CeBASE Method (Barry Boehm, Dan Port, Victor Basili, Apurva Jain)
Achieving CMMI Level 5 Improvements with MBASE and the CeBASE Method (pdf)
Barry Boehm, Dan Port, Victor Basili, Apurva Jain
Each branch of service in the Department of Defense has major initiatives to pursue more advanced software-intensive systems concepts involving network-centric warfare with self adaptive networks and cooperating human and autonomous agents. The ability to balance discipline and flexibility is critically important to developing such highly dependable software-intensive systems in an environment of rapid change. Risk-management orientation enables users of Capability Maturity Model® IntegrationSM (CMMISM) to apply risk considerations to determine how much discipline and how much flexibility is enough in a given situation. The risk-driven nature of the spiral model and MBASE enables them to achieve a similar balance of discipline and flexibility. When these project-level approaches are combined with the organization-level approaches in the Experience Factory, the result is the unified Center for Empirically Based Software Engineering (CeBASE) method described in this article.
USC-CSE-2001-513 - Risk-Based Strategic Software Design (Barry Boehm, Dan Port)
Barry Boehm, Dan Port, "Risk-Based Strategic Software Design," Economics-Driven Software Engineering Research, Toronto, Canada, May 2001 (pdf)
Risk consideration is a valuable assessment aid when making strategic software design decisions. Expressing development considerations in terms of risk exposures over an independent variable (e.g. time, cumulative effort, etc.) enables the quantitative assessment of typically qualitative attributes. Assuming total risk exposure is additive over individual risk exposure functions, optimal levels for the individual considerations can be identified as function of loss-magnitude and loss-probability estimates for risk sources. Such levels provide strategic trade off considerations (with respect to risk) and have proven valuable in several previous applications such as “how much testing is enough” with respect to defect removal and market window strategic risk considerations. Here we consider a similar application for making strategic design decisions in determining how much effort (or time) should be spent evaluating COTS products with respect to project cost, market window, and a multitude of COTS assessment attributes such as availability, ease of use, maturity, and vendor support.
Added June 24th, 2004
USC-CSE-2001-512 - Applying WinWin to Quality Requirements: A Case Study (Hoh Peter In, Barry Boehm, Thomas Rodgers, Michael Deutsch)
Hoh Peter In, Barry Boehm, Thomas Rodgers, Michael Deutsch, "Applying WinWin to Quality Requirements: A Case Study," 23rd ISCE, 2001, pp. 555-564 (pdf)
This paper describes the application of the WinWin paradigm to identify and resolve conflicts in a series of real-client, student-developer digital library projects. The paper is based on a case study of the statistical analysis of 15 projects and an in-depth analysis of one representative project. These analyses focus on the conflict resolution process, stakeholders' roles and their relationships to quality artificats, and tool effectiveness.
Added June 24th, 2004
USC-CSE-2001-511 - EasyWinWin: A Groupware-Supported Methodology for Requirement Negotiation (Barry Boehm, Paul Grunbacher, Robert O. Briggs)
Barry Boehm, Paul Grunbacher, Robert O. Briggs, "EasyWinWin: A Groupware-Supported Methodology for Requirement Negotiation," 8th European Software Engineering Conference (ESEC), 9th ACM SIGSOFT Symposium on The Foundations of Software Engineering (FSE-9), September 2001, pp. 320-321 (pdf)
EasyWinWin is a requirement definition methodology that builds on the win-win negotiation approach and leverages collaborative technology to improve the involvement and interaction of the key stakeholders. With EasyWinWin, stakeholders move through a step-by-step win-win negotiation where they collect, elaborate, and prioritize their requirements, and then surface and resolve issues.
Added June 24th, 2004
USC-CSE-2001-510 - Software Defect Reduction Top 10 List (Victor R. Basili, Barry Boehm)
Victor R. Basili, Barry Boehm, "Software Defect Reduction Top 10 List," Computer, January 2001, pp. 135-137 (pdf)
Recently, a National Science Foundation grant enabled us to establish the Center for Empirically Based Software Engineering. CeBASE seeks to transform software engineering as much as possible from a fad-based practice to an engineering-based practice through derivation, organization, and dissemination of empirical data on software development and evolution phenomenology. The phrase “as much as possible” reflects the fact that software development must remain a people-intensive and continually changing field. We have found, however, that researchers have established objective and quantitative data, relationships, and predictive models that help software developers avoid predictable pitfalls and improve their ability to predict and control efficient software projects.
Added June 24th, 2004
USC-CSE-2001-509 - Balancing Discipline and Flexibility with The Spiral Model and MBASE (Barry Boehm, Dan Port)
Barry Boehm, Dan Port, "Balancing Discipline and Flexibility with The Spiral Model and MBASE," CrossTalk: The Journal of Defense Software Engineering, December 2001, pp. 23-28 (pdf)
This article details how the spiral model and its recent extension, Model-Based Architecting and Software Engineering (MBASE) can be used to tailor a project’s balance of discipline and flexibility via risk considerations. It also describes and rationalizes the major MBASE extensions to the spiral model – model clash avoidance, stakeholder win-win – and elaborates on the use of these extensions and risk considerations in the anchor-point milestones used in MBASE and the spiral model.
Added June 24th, 2004
USC-CSE-2001-508 - Developing Groupware for Requirements Negotiation: Lessons Learned (Barry Boehm, Paul Grunbacher, Robert O. Briggs)
Barry Boehm, Paul Grunbacher, Robert O. Briggs, "Developing Groupware for Requirements Negotiation: Lessons Learned," IEEE Software, May/June 2001, pp. 46-55 (pdf, doc)
Defining requirements is a complex and difficult process, and defects in the process often lead to costly project failures. There is no complete and well-defined set of requirements waiting to be discovered in system development. Different stakeholders—users, customers, managers, domain experts, and developers—come to the project with diverse expectations and interests. Requirements emerge in a highly collaborative, interactive, and interdisciplinary negotiation process that involves heterogeneous stakeholders.
Added June 24th, 2004
USC-CSE-2001-505 - Early Experiences in Software Economics (Barry Boehm)
It took me a while to appreciate software economics.
My first exposure to software economics came on my first day in the software business, in June 1955 at General Dynamics in San Diego. My supervisor took me on a walking tour through the computer, an ERA 1103 which occupied most of a large room. His most memorable comment was,
"Now listen. We're paying this computer six hundred dollars an hour, and we're paying you two dollars an hour, and I want you to act accordingly."
Added May 5th, 2008
USC-CSE-2001-504 - COTS-Based Systems Top 10 List (Victor Basili, Barry Boehm)
Victor Basili, Barry Boehm, "COTS-Based Systems Top 10 List," Computer, Volume 34, Number 5, May, 2001, pp. 91-93 (pdf
In the January 2001 issue of Computer (pp. 135-137), we published the Software Defect Reduction Top 10 List—one of two foci pursued by the National Science Foundation-sponsored Center for Empirically Based Software Engineering (CeBASE).
COTS-based systems (CBS) provide the other CeBASE focus. For our intent, COTS software has the following characteristics: The buyer has no access to the source code; the vendor controls its development; and it has a nontrivial installed base (that is, more than one customer; more than a few copies).
Added May 15th, 2001
USC-CSE-2001-503 - The CeBASE Framework for Strategic Software Development and Evolution (Barry Boehm, Victor Basili)
Barry Boehm, Victor Basili, "The CeBASE Framework for Strategic Software Development and Evolution" (pdf)
One of the challenges highlighted in the EDSER-3 Call for Papers is for a symmetric approach to cost, risk, benefit, and opportunity modeling and management. This position paper offers the CeBASE Method as a response to this challenge. It is the result of an effort by the CeBASE principals at USC and U. of Maryland to reconcile their various models of software phenomenology into a common framework for pursuing empirical software engineering research and for organizing the results into a useful experience base.
Added May 15th, 2001
USC-CSE-2001-502 - Mastering Rapid Delivery and Change with The SAIV Process Model (Barry Boehm, A. Winsor Brown)
Barry Boehm, A. Winsor Brown, "Mastering Rapid Delivery and Change with The SAIV Process Model," Proceedings, ESCOM 2001, April 2001, pp. 147-156 (pdf)
Ensuring on time, within-budget delivery is increasingly difficulty in the information technology (IT) field because of the increasingly rapid rate of requirement volatility of IT systems under development. This paper describes the Model-Based (System) Architecting and Software Engineering (MBASE)’s Schedule as Independent Variable (SAIV) approach to this problem, and illustrates the nature of the solution with examples.
Added February 22nd, 2001
USC-CSE-2001-501 - Understanding the Spiral Model as a Tool for Evolutionary Acquisition (Barry Boehm, Wilfred J. Hansen)
Barry Boehm, Wilfred J. Hansen, "Understanding the Spiral Model as a Tool for Evolutionary Acquisition," submitted to ICSE 2001 (pdf)
Since its original publication [Boehm 88], the spiral development model has been used successfully in many defense and commercial projects. To extend this base of success the Department of Defense (DoD) has recently rewritten the defense acquisition regulations to incorporate "evolutionary acquisition," an acquisition strategy designed to mesh well with spiral development. In particular, DoD Instruction 5000.2 subdivides acquisition [DoD00]: "There are two ... approaches, evolutionary and single step to full capability. An evolutionary approach is preferred. … [In this] approach, the ultimate capability delivered to the user is divided into two or more blocks, with increasing increments of capability."
Added February 22nd, 2001
USC-CSE-2001-500 - Avoiding the Software Model-Clash Spiderweb (Barry Boehm, Dan Port, Mohammed Al-Said)
Barry Boehm, Dan Port, Mohammed Al-Said, "Avoiding the Software Model-Clash Spiderweb," Computer, Volume 33, Issue 11, November 2000, pp. 120-122 (pdf)
Analysts frequently describe troubled projects with the tarpit metaphor used o effectively in Fred Brooks’s The Mythical Man-Month (2nd ed., Addison-Wesley, Reading, Mass., 1995). We have found a similarly effective metaphor: Think of a troubled software project as an insect caught in a spiderweb of sticky constraints, trying desperately to break free before the spider arrives to feed.
Added May 15th, 2001
USC-CSE-2000-529 - Safe and Simple Software Cost Analysis (Barry Boehm)
Barry Boehm, "Safe and Simple Software Cost Analysis," IEEE Software, September/October 2000, pp. 14-17 (pdf)
There are a number of simple software cost analysis methods, but they may not always be safe. The simplest is to base your cost estimate on the typical costs or productivity rates of your previous projects. This will work well if your new project doesn’t have any cost-critical differences from your previous projects. But it won’t be safe if some critical cost-driver has changed for the worse.
Added June 24th, 2004
USC-CSE-2000-528 - Software Estimation Perspectives (Barry Boehm, Richard Fairley)
Barry Boehm, Richard Fairley, "Software Estimation Perspectives," IEEE Software, November/December 2000, pp. 22-26 (pdf)
How much is 68 + 73? Engineer: “It’s 141.” Short and sweet. Mathematician: “68 + 73 = 73 + 68 by the commutative law of addition.” True, but not very helpful. Accountant: “Normally it’s 141, but what are you going to use it for?”
Added June 24th, 2004
USC-CSE-2000-527 - Requirements that Handle IKIWISI, COTS, and Rapid Change (Barry Boehm)
Barry Boehm, "Requirements that Handle IKIWISI, COTS, and Rapid Change," Computer, July 2000, pp. 99-102 (pdf)
In the good old days, dealing with software requirements was relatively easy. Software requirements were the first order of business and took place before design, cost estimation, planning, or programming. Of course, it wasn’t simple.
Added June 24th, 2004
USC-CSE-2000-526 - The Art of Expectations Management (Barry Boehm)
Barry Boehm, "The Art of Expectations Management," Computer, January 2000, pp. 122-124 (pdf)
One of the most valuable skills a software professional can develop, expectation management is something surprisingly few people know or practice. I’ve witnessed more than 100 stakeholder software requirement negotiations in which inflated expectations about the simplicity of the problem or ease of providing a solution have caused the most difficulty. Expectations management holds the key to providing win-win solutions to these situations.
Added June 24th, 2004
USC-CSE-2000-525 - Spiral Development: Experience, Principles, and Refinements (Barry Boehm)
Barry Boehm, "Spiral Development: Experience, Principles, and Refinements," Spiral Development Workshop, edited by Wilfred J. Hansen, February 9, 2000 (pdf)
Spiral development is a family of software development processes characterized by repeatedly iterating a set of elemental development processes and managing risk so it is actively being reduced. This paper characterizes spiral development by enumerating a few “invariant” properties that any such process must exhibit. For each, a set of “variants” is also presented, demonstrating a range of process definitions in the spiral development family. Each invariant excludes one or more "hazardous spiral look-alike" models, which are also outlined. This report also shows how the spiral model can be used for a more cost-effective incremental commitment of funds, via an analogy of the spiral model to stud poker. An important and relatively recent innovation to the spiral model has been the introduction of anchor point milestones. The latter part of the paper describes and discusses these.
Added February 22nd, 2001
USC-CSE-2000-522 - Focus: A Light-Weight, Incremental Approach to Software Architecture Recovery and Evolution (Lei Ding, Nenad Medvidovic, Barry Boehm)
During the past decade, object-orientation (OO) has become the dominant software development methodology, accompanied by a number of modeling notations, programming languages, and development environments. OO applications of today are increasingly complex and user-driven. They are also developed more rapidly and evolved more frequently than was the case with software systems of the past. All of these factors contribute to a plethora of potential problems when maintaining and evolving an OO application. These problems are caused by architectural erosion, where the initial architecture of an application is (arbitrarily) modified to the point where its key properties no longer hold. We propose an approach, called Focus, whose goal is to enable effective evolution of such an application with minimal effort, by recovering its architecture and using it as the basis of evolution. Focus allows engineers to direct their primary attention to the part of the system that is directly impacted by the desired change; subsequent changes will incrementally uncover additional parts of the system’s architecture. We have applied Focus to four off-the-shelf applications to date. We discuss its key strengths and point out several open issues that will frame our future work.
Added November 13th, 2000
USC-CSE-2000-521 - Bridging Models across the Software Lifecycle (Nenad Medvidovic, Paul Gruenbacher, Alexander Egyed, Barry Boehm)
Nenad Medvidovic, Paul Gruenbacher, Alexander Egyed, Barry Boehm, "Bridging Models across the Software Lifecycle," Journal of Systems and Software, Special issue: Best papers on Software Engineering from the SEKE'01 Conference, Volume 68, Issue 3, December 2003, pp. 199-215 (pdf)
Numerous notations, methodologies, and tools exist to support software system modeling. While individual models may clarify certain system aspects, the large number and heterogeneity of models may ultimately hamper the ability of stakeholders to communicate about a system. A major reason for this is the discontinuity of information across different models. In this paper, we present an approach for dealing with that discontinuity. We introduce a set of transformations to bridge models, both within and across the “upstream” activities in the software development lifecycle (specifically, requirements, architecture, and design). While the details of these transformations are dependent upon the source and destination models, they share a number of underlying characteristics. These characteristics can be used as a starting point in providing a general understanding of transformations between software models. We illustrate our approach by applying it to a large-scale system we are currently designing and implementing in collaboration with a third-party organization.
Added November 13th, 2000
USC-CSE-2000-511 - Gaining Intellectual Control of Software Development (Barry Boehm, Victor R. Basili)
Barry Boehm, Victor R. Basili "Gaining Intellectual Control of Software Development," IEEE Computer, Volume 33, Number 5, May 2000, pp. 27-33 (pdf)
Recent disruptions caused by several events have shown how thoroughly the world has come to depend on software. The rapid proliferation of the Melissa virus hinted at a dark side to the ubiquitous connectivity that supports the information-rich Internet and lets e-commerce thrive. Although the oft-predicted Y2K apocalypse failed to materialize, many software experts insist that disaster was averted only because countries around the globe spent billions to ensure their critical software would be Y2K-compliant. When denial-of-service attacks shut down some of the largest sites on the Web last February, the concerns caused by the disruptions spread far beyond the complaints of frustrated customers, affecting even the stock prices of the targeted sites.
Added October 10th, 2000
USC-CSE-2000-510 - COTS Integration: Plug and Pray? (Barry Boehm, Chris Abts)
Barry Boehm, Chris Abts, "COTS Integration: Plug and Pray?" Computer, Volume 32, Number 1, January 1999, pp. 135-138 (pdf)
For most software applications, the use of commercial off-the-shelf products has become an economic necessity. Gone are the days when upsized industry and government information technology organizations had the luxury of trying to develop—and at greater expense, maintain— their own database, network, and user-interface management infrastructure. Viable COTS products are climbing up the protocol stack, from infrastructure into application solutions in such areas as office and management support, electronic commerce, finance, logistics, manufacturing, law, and medicine. For small and large commercial companies, time-to-market pressure also exert a strong pressure toward COTS-based solutions.
Added October 10th, 2000
USC-CSE-2000-509 - Software Economics: A Roadmap (Barry Boehm, Kevin J. Sullivan)
Barry Boehm, Kevin J. Sullivan, "Software Economics: A Roadmap," Proceedings of the Conference on The Future of Software Engineering, ICSE 2000, Limerick, Ireland, 2000, pp. 319-343 (pdf)
The fundamental goal of all good design and engineering is to create maximal value added for any given investment. There are many dimensions in which value can be assessed, from monetary profit to the solution of social problems. The benefits sought are often domain-specific, yet the logic is the same: design is an investment activity. Software economics is the field that seeks to enable significant improvements in software design and engineering through economic reasoning about product, process, program, and portfolio and policy issues. We summarize the state of the art and identify shortfalls in existing knowledge. Past work focuses largely on costs, not on benefits, thus not on value added; nor are current technical software design criteria linked clearly to value creation. We present a roadmap for research emphasizing the need for a strategic investment approach to software engineering. We discuss how software economics can lead to fundamental improvements in software design and engineering, in theory and practice.
Added October 10th, 2000
USC-CSE-2000-508 - Managing Software Productivity and Reuse (Barry Boehm)
Barry Boehm, "Managing Software Productivity and Reuse," Computer, Volume 32, Issue 9, September 1999, pp. 111-113 (pdf)
Your organization can choose from three main strategies for improving its software productivity. You can work faster, using tools that automate or speed up previously labor-intensive tasks. You can work smarter, primarily through process improvements that avoid or reduce non-value-adding tasks. Or you can avoid unnecessary work by reusing software artifacts instead of custom developing each project. Which strategy will produce the highest payoff?
Added October 10th, 2000
USC-CSE-2000-507 - Spiral Development: Experience, Principles, and Refinements (Barry Boehm)
Barry Boehm, "Spiral Development: Experience, Principles, and Refinements," Spiral Experience Workshop, February 9, 2000 (pdf)
This presentation opened the USC-SEI Workshop on Spiral Development* Experience and Implementation Challenges held at USC February 9-11, 2000. The workshop brought together leading executives and practitioners with experience in transitioning to spiral development of software-intensive systems in the commercial, aerospace, and government sectors. Its objectives were to distill the participants’ experiences into a set of critical success factors for transitioning to and successfully implementing spiral development, and to identify the most important needs, opportunities, and actions to expedite organizations’ transition to successful spiral development. To provide a starting point for addressing these objectives, I tried in this talk to distill my experiences in developing and transitioning the spiral model at TRW; in using it in system acquisitions at DARPA; in trying to refine it to address problems that people have had in applying it in numerous commercial, aerospace, and government contexts; and in working with the developers of major elaborations and refinements of the spiral model such that the Software Productivity Consortium’s Evolutionary Spiral Process [SPC, 1994] and Rational, Inc’s Rational Unified Process [Royce, 1998; Kruchten 1999; Jacobson et al., 1999]. I’ve modified the presentation somewhat to reflect the experience and discussions at the Workshop.
Added March 28th, 2000
USC-CSE-2000-506 - Unifying Software Engineering and Systems Engineering (Barry Boehm)
Barry Boehm, "Unifying Software Engineering and System Engineering," Computer, Volume 3, Number 3, March 2000, pp. 114-116 (pdf)
Rapid change in information technology brings with it a frequent need to undo the effects of previous culture change efforts. This process, while often challenging and frustrating, offers numerous rewards for success. Organizations can change from slow, reactive, adversarial, separated software and systems engineering processes to unified, concurrent processes. These processes better suit rapid development of dynamically changing software-intensive systems involving COTS, agent, Web, multimedia, and Internet technology.
Added October 10th, 2000
USC-CSE-2000-505 - Software Development Cost Estimation Approaches - A Survey (Barry Boehm, Chris Abts, Sunita Chulani)
Barry Boehm, Chris Abts, Sunita Chulani, "Software Development Cost Estimation Approaches - A Survey," Qualifying Exam Report (Sunita Chulani) (pdf)
This paper summarizes several classes of software cost estimation models and techniques: parametric models, expertise-based techniques, learning-oriented techniques, dynamics-based models, regression-based models, and composite-Bayesian techniques for integrating expertise-based and regression-based models. Experience to date indicates that neural-net and dynamics-based techniques are less mature than the other classes of techniques, but that all classes of techniques are challenged by the rapid pace of change in software technology. The primary conclusion is that no single technique is best for all situations, and that a careful comparison of the results of several approaches is most likely to produce realistic estimates.
Added April 10th, 2000
USC-CSE-2000-504 - Empirical Analysis of CASE Tool Effects on Software Development Effort (Jongmoon Baik, Barry Boehm)
During the last couple of decades, CASE (Computer Aided Software Engineering) tools have played a critical role in improvement of software productivity and quality by assisting tasks in software development processes. Many initiatives in the field were pursued in the 1980’s and 1990’s to provide more effective CASE technologies and development environments. Even though the CASE field is no longer active research area, most software development teams use a huge range of CASE tools that are typically assembled over some period with the hope of productivity and quality improvements throughout the software development process. The variety and proliferation of tools in the current CASE market makes it difficult to understand what kinds of tasks are supported and how much effort can be reduced by using CASE tools. In this paper, we provide a classification of CASE tools by activity coverage in a software development lifecycle. We also report a experimental result of Bayesian analysis on CASE tool effects with a extended set of tool rating scales from COCOMO (COnstructive COst MOdel) II with which CASE tools are effectively evaluated.
Added March 20th, 2000
USC-CSE-2000-502 - Empirical Observations on COTS Software Integration Effort Based on the Initial COCOTS Calibration Database (Chris Abts, Barry Boehm, Elizabeth Bailey Clark)
Chris Abts, Barry Boehm, Elizabeth Bailey Clark, "Empirical Observations on COTS Software Integration Effort Based on the Initial COCOTS Calibration Database," Proceedings of the Twenty-Fifth Annual Software Engineering Workshop (SEW 25), NASA/Goddard Space Flight Center, 2000 (pdf)
As the use of commercial-of-the-shelf (COTS) components becomes ever more prevalent in the creation of large software systems, the need for the ability to reasonably predict the true lifetime cost of using such software components grows accordingly. This paper presents empirically-based findings about the effort associated with activities found to be significant in the development of systems using COTS components. The findings are based upon data collected for the purpose of calibrating the COCOTS COTS software integration cost model, an extension to the COCOMO II cost model designed to capture costs COCOMO does not. A brief overview of COCOTS is presented to put the data in perspective, including its relation to COCOMO II. A set of histograms is then shown summarizing the effort data collected to date. The paper concludes with some observations suggested by an examination of that calibration data.
Added March 8th, 2000
USC-CSE-2000-501 - COCOTS: A COTS Software Integration Lifecycle Cost Model - Model Overview and Preliminary Data Collection Findings (Chris Abts, Barry Boehm, Elizabeth Bailey Clark)
Chris Abts, Barry Boehm, Elizabeth Bailey Clark, "COCOTS: A COTS Software Integration Lifecycle Cost Model - Model Overview and Preliminary Data Collection Findings," Proceedings ESCOM-SCOPE 2000 Conference, Munich, Germany, April 18-20, 2000, pp. 325-333 (pdf)
As the use of commercial-of-the-shelf (COTS) components becomes ever more prevalent in the creation of large software systems, the need for the ability to reasonably predict the true lifetime cost of using such software components grows accordingly. In using COTS components, immediate short-term gains in direct development effort & schedule are possible, but usually as a trade-off for a more complicated long-term post-deployment maintenance environment. In addition, there are risks associated with COTS software separate from those of creating components from scratch. These unique risks can further complicate the development and post-deployment situations. This paper discusses a model being developed as an extension of the COCOMO II cost model. COCOTS attempts to predict the lifecycle costs of using COTS components by capturing the more significant COTS risks in its modeling parameters. The current state of the model is presented, along with some preliminary findings suggested by an analysis of calibration data collected to date. The paper concludes with a discussion of the on-going effort to further refine the accuracy and scope of COCOTS.
Added March 8th, 2000
USC-CSE-2000-500 - USC COCOMO II.2000 (Barry Boehm, Chris Abts, Jongmoon Baik, A. Winsor Brown, Sunita Chulani, Bradford Clark, Ellis Horowitz, Ray Madachy, Donald J. Reifer, Bert Steece)
Barry Boehm, Chris Abts, Jongmoon Baik, A. Winsor Brown, Sunita Chulani, Bradford Clark, Ellis Horowitz, Ray Madachy, Don Reifer, Bert Steece, "USC COCOMO II.2000" (pdf)
This manual presents two models, the Post-Architecture and Early Design models. These two models are used in the development of Application Generator, System Integration, or Infrastructure developments [Boehm et al. 2000]. The Post-Architecture is a detailed model that is used once the project is ready to develop and sustain a fielded system. The system should have a life-cycle architecture package, which provides detailed information on cost driver inputs, and enables more accurate cost estimates. The Early Design model is a high-level model that is used to explore of architectural alternatives or incremental development strategies. This level of detail is consistent with the general level of information available and the general level of estimation accuracy needed.
The Post-Architecture and Early Design models use the same approach for product sizing (including reuse) and for scale factors. These will be presented first. Then, the Post-Architecture model will be explained followed by the Early Design model.
Added September 8th, 2008
USC-CSE-99-530 - Cost vs. Quality Requirements: Conflict Analysis and Negotiation Aids (Barry Boehm, Hoh Peter In)
Barry Boehm, Hoh Peter In, "Cost vs. Quality Requirements: Conflict Analysis and Negotiation Aids," Software Quality Professional, Volume 1, Number 2, March 1999, pp. 38-50 (pdf)
The process of resolving conflicts among software quality requirements is complex and difficult because of incompatibility among stakeholders' interests and priorities, complex cost-quality requirements dependencies, and an exponentially increasing resolution option space for larger systems. This paper describes an exploratory knowledge-based tool, the Software Cost Option Strategy Tool(S-COST), which assists stakeholders to 1) surface appropriate resolution options for cost-quality conflicts; 2) visualize the options; and 3) negotiate a mutually satisfactory balance of quality requirements and cost.
S-COST operates in the context of the USC-CSE WinWin system (a groupware support system for determining software and system requirements as negotiated win conditions), QARCC (Quality Attribute and Risk Conflict Consultant - a support system for identifying quality conflicts in software requirements), and COCOMO (Constructive, Cost estimation Model). Initial analysis of its capabilities indicate that its semiautomated approach provides users with improved capabilities for addressing cost-quality requirements issues.
Added November 11th, 2005
USC-CSE-99-525 - Supporting Distributed Collaborative Prioritization (Jung-Won Park, Dan Port, Barry Boehm)
Jung-Won Park, Dan Port, Barry Boehm, "Supporting Distributed Collaborative Prioritization," APSEC, Sixth Asia-Pacific Software Engineering Conference (APSEC'99), 1999, pp. 560 (pdf)
Software developers are seldom able to implement stakeholders' requirements fully when time and resources are limited. To solve the problem, requirement engineers together with the stakeholders must prioritize requirements. The problem is exacerbated when the stakeholders are not all in the same place and/or can not collaborate at the same time. We have constructed a system called the Distributed Collaboration and Prioritization Tool (DCPT) to support the distributed and collaborative prioritization. In this paper, we will discuss the prioritization model implemented within DCPT and will give examples of using the tool. We will also discuss DCPT's integration with USC's WinWin requirements capture and negotiation system.
Added September 17th, 1999
USC-CSE-99-523 - When Models Collide: Lessons From Software System Analysis (Barry Boehm, Dan Port)
Barry Boehm, Dan Port, "When Models Collide: Lessons From Software System Analysis," IT Professional, Volume 1, Number 1, January-February 1999, pp. 49-56 (pdf)
This paper analyzes several classes of model clashes encountered on large, failed IT projects (e.g., Confirm, Master Net), and shows how the MBASE approach could have detected and resolved the clashes.
The first step in developing either an applicaiton or a system is to visualise it. The first step in developing either an application or a system is to visualize it. And when you visualize a system, you can’t help but use intellectual models to rea-son about what you’re building and how it will behave. The model can be a pattern you follow or an analogy you use. Whatever the form, models are ubiquitous: Developers use them in building a small stand-alone package or a large custom system. Customers use them to visualize what they think they’re getting from developers.
Added July 8th, 1999
USC-CSE-99-521 - Comparing Software System Negotiation Requirements Patterns (Alexander Egyed, Barry Boehm)
Alexander Egyed, Barry Boehm, "Comparing Software System Requirements Negotiation Patterns," Journal for Systems Engineering, John Wiley & Sons, 1999 (pdf)
In a period of two years, two rather independent experiments were conducted at the University of Southern California (USC). In 1995, 23 three-person teams negotiated the requirements for a hypothetical library system. Then, in 1996, 14 six-person teams negotiated the requirements for real-world digital library systems.
A number of hypotheses were created to test how more realistic software projects differ from hypothetical ones. Other hypotheses address differences in uniformity and repeatability of negotiation processes and results. The results indicate that repeatability in 1996 was even harder to achieve then in 1995. Nevertheless, this paper presents some surprising commonalties between both years that indicate some areas of uniformity.
As such we found that the more realistic projects required more time to resolve conflicts and to identify options (alternatives) than the hypothetical ones. Further, the 1996 projects created more artifacts although they exhibited less artifact interconnectivity, implying a more divide and conquer negotiation approach. In terms of commonalties, we found that people factors such as experience did have effects onto negotiation patterns (especially in 1996), that users and customers were most significant (in terms of artifact creation) during the goal identification whereas the developers were more significant in identifying issues (conflicts) and options. We also found that both years exhibited some strange although similar disproportional stakeholder participation.
Added July 7th, 1999
USC-CSE-99-520 - Optimizing Software Product Integrity through Life-Cycle Process Integration (Barry Boehm, Alexander Egyed)
Barry Boehm, Alexander Egyed, "Optimizing Software Product Integrity through Life-Cycle Process Integration," Computer Standards and Interfaces, Volume 21, Issue 1, May 1999, pp. 63-75 (pdf)
Managed and optimized - these are the names for the levels 4 and 5 of the Capability Maturity Model (CMM) respectively. With that the Software Engineering Institute (SEI) pays tribute to the fact that, after the process has been defined, higher process maturity, and with that higher product maturity, can only be achieved by improving and optimizing the life-cycle process itself.
In the last three years, we had had the opportunity to observe more than 50 software development teams in planning, specifying and building library related, real-world applications. This environment provided us with a unique way of introducing, validating and improving the life cycle process with new principles such as the WinWin approach to software development.
This paper summarizes the lessons we have learned in our ongoing endeavor to integrate the WinWin life-cycle process. In doing so, we will not only describe what techniques have proven to be useful in getting the developer’s task done but the reader will also get some insight on how to tackle process improvement itself. As more and more companies are reaching CMM levels two or higher this task, of managing and optimizing the process, becomes increasingly important.
Added July 7th, 1999
USC-CSE-99-516 - Supporting Distributed Collaborative Prioritization for WinWin Requirements Capture and Negotiations (Jung-Won Park, Dan Port, Barry Boehm, Hoh Peter In)
Jung-Won Park, Dan Port, Barry Boehm, Hoh Peter In, "Supporting Distributed Collaborative Prioritization for WinWin Requirements Capture and Negotiations," Proceedings of 3rd World Multiconference on Systemics, Cybernetics and Informatics (SCI'99), IIIS, Volume 2, pp. 578-584 (pdf)
One of the most common problems within a risk driven software collaborative development effort is prioritizing items such as requirements, goals, and stakeholder win-conditions. Requirements have proven particularly sticky in this as it is often the case that they can not be fully implemented when time and resources are limited introducing additional risk to the project. A practical approach to mitigating this risk in alignment with the WinWin development approach is to have the critical stakeholders for the project collaboratively negotiate requirements into priority bins which then are scheduled into an appropriate incremental development life cycle.
We have constructed a system called the Distributed Collaboration Priorities Tool (DCPT) which to assist in collaborative prioritization of development items. DCPT offers a strcutually guided approach to collaborative prioritization much in the spirit of USC's WinWin requirements capture and negotiation system. In this paper, we will discuss the prioritization models implemented within DCPT via an actual prioritization of new WinWin system features. We also discuss DCPT's two-way integration with WinWin system, some experiences using DCPT, and current research directions.
Added April 5th, 1999
USC-CSE-99-513 - Bayesian Analysis of Empirical Software Engineering Cost Models (Sunita Chulani, Barry Boehm, Bert Steece)
Sunita Chulani, Barry Boehm, Bert Steece, "Bayesian Analysis of Empirical Software Engineering Cost Models," IEEE-TSE; Special Issue on Empirical Methods, Volume 25, Issue 4, July 1999, pp. 573-583 (pdf)
The most commonly used technique for empirical calibration of software cost models has been the popular classical multiple regression approach. As discussed in this paper, the multiple regression approach imposes a few assumptions frequently violated by software engineering datasets. The source data is also generally imprecise in reporting size, effort and cost-driver ratings, particularly across different organizations. This results in the development of inaccurate empirical models that don't perform very well when used for prediction. This paper illustrates the problems faced by the multiple regression approach during the calibration of one of the popular software engineering cost models, COCOMO II. It describes the use of a pragmatic 10% weighted average approach that was used for the first publicly available calibrated version [Clark98]. It then moves on to show how a more sophisticated Bayesian approach can be used to alleviate some of the problems faced by multiple regression. It compares and contrasts the two empirical approaches, and concludes that the Bayesian approach was better and more robust than the multiple regression approach.
Added March 11th, 1999
USC-CSE-99-512 - Making RAD Work for Your Project (Barry Boehm)
Barry Boehm, "Making RAD Work for Your Project," extended version of IEEE Computer, Volume 32, Number 3, March 1999, pp. 113-114,117 (pdf)
A significant recent trend we have observed among our USC Center for Software Engineering's industry and government Affiliates is that reducing the schedule of a software development project was becoming considerably more important than reducing its cost. This led to an Affiliates' Workshop on Rapid Application Development (RAD) to explore its trends and issues. Some of the main things we learned at the workshop were:
There are good business reasons why software development schedule is often more important than cost.
There are various forms of RAD. None are best for all situations. Some are to be avoided in all situations.
For mainstream software development projects, we could construct a RAD Opportunity Tree which helps sort out the best RAD mixed strategy for a given situation.
Cost, schedule and quality are highly correlated factors in software development. They basically form three sides of the same triangle. Beyond a certain point (the "Quality is Free" point), it is difficult to increase the quality without increasing either the cost or schedule or both for the software under development. Similarly, development schedule cannot be drastically compressed without hampering the quality of the software product and/or increasing the cost of development. Watts Humphrey, at the LA SPIN meeting in December '98, highlighted that "Measuring Productivity without caring about Quality has no meaning". Software estimation models can (and should) play an important role in facilitating the balance of cost/schedule and quality.
Recognizing this important association, an attempt is being made to develop a quality model extension to COCOMO II; namely COQUALMO. An initial description of this model focusing on defect introduction was provided in [Chulani97a]. The model has evolved considerably since then and is now very well defined and calibrated to Delphi-gathered expert opinion. The data collection activity is underway and the aim is to have a statistically calibrated model by the onset of the next millennium.
The many benefits of cost/quality modeling include:
Resource allocation: The primary but not the only important use of software estimation is budgeting for the development life cycle.
Tradeoff and risk analysis: An important capability is to enable 'what-if' analyses that demonstrate the impact of various defect removal techniques and the effects of personnel, project, product and platform characteristics on software quality. A related capability is to illuminate the cost/schedule/quality trade-offs and sensitivities of software project decisions such as scoping, staffing, tools, reuse, etc.
Time to Market initiatives: An important additional capability is to provide cost/schedule/quality planning and control by providing breakdowns by component, stage and activity to facilitate the Time To Market initiatives.
Software quality improvement investment analysis: A very important capability is to estimate the costs and defect densities and assess the return on investment of quality initiatives such as use of mature tools, peer reviews and disciplines methods.
Added March 3rd, 1999
USC-CSE-98-520 - COTS Software Integration Cost Modeling Study (Chris Abts, Barry Boehm)
Chris Abts, Barry Boehm, "COTS Software Integration Cost Modeling Study," final report under DoD contract F30602-94-C-1095 (pdf)
This study represents a first effort towards the goal of developing a comprehensive COTS integration cost modeling tool. The approach taken was to first examine a wide variety of sources in an attempt to identify the most significant factors driving COTS integration costs, and to develop a mathematical form for such a model. These sources ranged from already existing cost models to information gathered in a preliminary high level data collection survey. Once the form and candidate drivers had been identified, the next step was to gather project level COTS integration effort data in a second round data collection exercise. This project level data was then used to calibrate and validate the proposed model. Data from both a graduate level software engineering class and from industrial sources were used in calibration attempts. The industrial data proved problematic, however, so for the purposes of this study, the final calibration of the model was based upon the student projects.
The final result was a cost model following the general form of the well-known COCOMO software cost estimation model, but with an alternate set of cost drivers. The scope of the model is also narrow, addressing only initial integration coding costs. The predictive power of the model at this stage is only fair, but it was demonstrated that with appropriate data, the accuracy of the model could be greatly improved.
Finally, the richness to the problem of capturing all significant costs associated with using COTS software offers many worth-while directions in which to expand the scope of this model.
Added September 24th, 1998
USC-CSE-98-519 - Guidelines for the Life Cycle Objectives (LCO) and the Life Cycle Architecture (LCA) deliverables for Model-Based Architecting and Software Engineering (MBASE) (Barry Boehm, Dan Port, Marwan Abi-Antoun, Alexander Egyed)
Barry Boehm, Dan Port, Marwan Abi-Antoun, Alexander Egyed, "Guidelines for the Life Cycle Objectives (LCO) and the Life Cycle Architecture (LCA) deliverables for Model-Based Architecting and Software Engineering (MBASE)" (pdf)
Over our three years of developing digital library products for the USC Libraries, we have been evolving an approach called Model-Based (System) Architecting and Software Engineering (MBASE). MBASE involves early reconciliation of a project's success models, product models, process models, and property models. It extends the previous spiral model in two ways: initiating each spiral cycle with a stakeholder win-win stage to determine a mutually satisfactory (win-win) set of objectives, constraints, and alternatives for the system's next elaboration during the cycle; orienting the spiral cycles to synchronize with a set of life cycle anchor points: Life Cycle Objectives (LCO), Life Cycle Architecture (LCA), and Initial Operational Capability (IOC).
The MBASE guidelines present the content and the completion criteria for the LCO and LCA milestones (which correspond to the Inception and Elaboration Phases of the Rational Unified Process) of the following system definition elements: Operational Concept Description (OCD); System and Software Requirements Definition (SSRD); System and Software Architecture Description (SSAD); Life Cycle Plan (LCP); Feasibility Rationale Description (FRD); Risk-driven prototypes.
Added September 24th, 1998
USC-CSE-98-518 - Requirements Engineering, Expectations Management, and The Two Cultures (Barry Boehm, Marwan Abi-Antoun, Dan Port, Julie Kwan, Anne Lynch)
Barry Boehm, Marwan Abi-Antoun, Dan Port, Julie Kwan, Anne Lynch, "Requirements Engineering, Expectations Management, and The Two Cultures," Proceedings of the 4th IEEE International Symposium on Requirements Engineering, June 1999, pp. 14-22 (pdf)
In his seminal work, The Two Cultures, C.P. Snow found that science and technology policymaking was extremely difficult because it required the combined expertise of both scientists and politicians, whose two cultures had little understanding of each other's principles and practices [Snow, 1959].
During the last three years, we have conducted over 50 real-client requirements negotiations for digital library applications projects. Those largely involve professional librarians as clients and 5-6 person teams of computer science MS-degree students as developers. We have found that their two-cultures problem is one of the most difficult challenges to overcome in determining a feasible and mutually satisfactory set of requirements for these applications.
During the last year, we have been experimenting with expectations management and domain-specific lists of "simplifiers and complicators" as a way to address the two-cultures problem for software requirements within the overall digital library domain. Section 2 of this paper provides overall motivation and context for addressing the two-cultures problem and expectations management as significant opportunity areas in requirements engineering. Section 3 discusses the digital library domain and our stakeholder Win-Win and Model-Based (System) Architecting and Software Engineering (MBASE) approach as applied to digital library projects. Section 4 discusses our need for better expectations management in determining the requirements for the digital library projects are products over the first two years, and describes our approach in year 3 to address the two-cultures problem via expectations management. Section 5 summarizes results to date and future prospects.
Added September 24th, 1998
USC-CSE-98-517 - Escaping the Software Tar Pit: Model Clashes and How to Avoid Them (Barry Boehm, Dan Port)
Barry Boehm, Dan Port, "Escaping the Software Tar Pit: Model Clashes and How to Avoid Them," ACM Software Engineering Notes, January 1999, pp. 36-48 (pdf)
"No scene from prehistory is quite so vivid as that of the mortal struggles of great beasts in the tar pits... Large system programming has over the past decade been such a tar pit, and many great and powerful beasts have thrashed violently in it... Everyone seems to have been surprised by the stickiness of the problem, and it is hard to discern the nature of it. But we must try to understand it if we are to solve it." Fred Brooks, 1975
Several recent books and reports have confirmed that the software tar pit is at least as hazardous today as it was in 1975. Our research into several classes of models used to guide software development (product models, process models, property models, success models), has convinced us that the concept of model clashes among these classes of models helps explain much of the stickiness of the software tar-pit problem.
We have been developing and experimentally evolving an approach called MBASE -- Model-Based (System) Architecting and Software Engineering -- which helps identify and avoid software model clashes. Section 2 of this paper introduces the concept of model clashes, and provides examples of common clashes for each combination of product, process, property, and success model. Sections 3 and 4 introduce the MBASE approach for endowing a software project with a mutually supportive set of models, and illustrate the application of MBASE to an example corporate resource scheduling system. Section 5 summarizes the results of applying the MBASE approach to a family of small digital library projects. Section 6 presents conclusions to date.
Added September 24th, 1998
USC-CSE-98-516 - The Rosetta Stone: Making COCOMO 81 Files Work With COCOMO II (Donald J. Reifer, Barry Boehm, Sunita Chulani)
Donald J. Reifer, Barry Boehm, Sunita Chulani, "The Rosetta Stone: Making COCOMO 81 Files Work With COCOMO II," CrossTalk, February 1999, pp. 11-15 (pdf)
As part of our efforts to help COCOMO users, we, the COCOMO research team at the Center for Software Engineering at the University of Southern California (USC), have developed the Rosetta Stone for converting COCOMO 81 files to run using the new COCOMO II software cost estimating model. The Rosetta Stone is very important because it allows users to update estimates made with the earlier version of the model so that they can take full advantage of the many new features incorporated into the COCOMO II package. This paper describes both the Rosetta Stone and guidelines for making the job of conversion easy.
Added September 24th, 1998
USC-CSE-98-513 - Conceptual Modeling Challenges for Model-Based Architecting and Software Engineering (MBASE) (Barry Boehm, Dan Port)
Barry Boehm, Dan Port, "Conceptual Modeling Challenges for Model-Based Architecting and Software Engineering (MBASE)," to appear in Proceedings, Conceptual Modeling Symposium (pdf)
The difference between failure and success in developing a software-intensive system can often be traced to the presence or absence of clashes among the models used to define the system’s product, process, property, and success characteristics. (Here, we use a simplified version of one of Webster’s definitions of “model” a description or analogy used to help visualize something. We include analysis as a form of visualization).
Section 2 of this paper introduces the concept of model clashes, and provides examples of common clashes for each combination of product, process, property, and success models. Section 3 introduces the Model-Based Architecting and Software Engineering (MBASE) approach for endowing a software project with a mutually supportive base of models. Section 4 presents examples of applying the MBASE approach to a family of digital library projects. Section 5 summarizes the main conceptual modeling challenges involved in the MBASE approach, including integration of multiple product views and integration of various classes of product, process, property, and success models. Section 6 summarizes current conclusions and future prospects.
Added August 20th, 1998
USC-CSE-98-512 - Using the WinWin Spiral Model: A Case Study (Barry Boehm, Alexander Egyed, Dan Port, Archita Shah, Julie Kwan, Ray Madachy)
Barry Boehm, Alexander Egyed, Dan Port, Archita Shah, Julie Kwan, Ray Madachy, "Using the WinWin Spiral Model: A Case Study," IEEE Computer, Volume 31, Number 7, July 1998, pp. 33-44 (pdf)
Fifteen teams used the WinWin spiral model to prototype, plan, specify, and build multimedia applications for USC’s Integrated Library System. The authors report lessons learned from this case study and how they extended the model’s utility and cost-effectiveness in a second round of projects.
Added August 18th, 1998
USC-CSE-98-511 - A Stakeholder Win-Win Approach to Software Engineering Education (Barry Boehm, Alexander Egyed, Dan Port, Archita Shah, Julie Kwan, Ray Madachy)
Barry Boehm, Alexander Egyed, Dan Port, Archita Shah, Julie Kwan, Ray Madachy, "A Stakeholder Win-Win Approach to Software Engineering Education," Annals of Software Engineering, 1998, pp. 295-321 (pdf)
We are applying the stakeholder win-win approach to software engineering education. The key stakeholders we are trying to simultaneously satisfy are the students; the industry recipients of our graduates; the software engineering community as parties interested in improved practices; and ourselves as instructors and teaching assistants. In order to satisfy the objectives or win conditions of these stakeholders, we formed a strategic alliance with the University of Southern California Libraries to have software engineering student teams work with Library clients to define, develop, and transition USC digital library applications into operational use. This adds another set of key stakeholders: the Library clients of our class projects. This paper summarizes our experience in developing, conducting, and iterating the course. It concludes by evaluating the degree to which we have been able to meet the stakeholder-determined course objectives.
Added August 18th, 1998
USC-CSE-98-510 - The MBASE Life Cycle Architecture Milestone Package: No Architecture Is An Island (Barry Boehm, Dan Port, Alexander Egyed, Marwan Abi-Antoun)
Barry Boehm, Dan Port, Alexander Egyed, Marwan Abi-Antoun, "The MBASE Life Cycle Architecture Milestone Package: No Architecture Is An Island," WICSA '99 (pdf)
This paper summarizes the primary criteria for evaluating software/system architectures in terms of key system stakeholders’ concerns. It describes the Model Based Architecting and Software Engineering (MBASE) approach for concurrent definition of a system’s architecture, requirements, operational concept, prototypes, and life cycle plans. It summarizes our experiences in using and refining the MBASE approach on 31 digital library projects. It concludes that a Feasibility Rationale demonstrating consistency and feasibility of the various specifications and plans is an essential part of the architecture’s definition, and presents the current MBASE annotated outline and guidelines for developing such a Feasibility Rationale.
Added August 17th, 1998
USC-CSE-98-509 - Improving the Life-Cycle Process in Software Engineering Education (Barry Boehm, Alexander Egyed)
Barry Boehm, Alexander Egyed, "Improving the Life-Cycle Process in Software Engineering Education," accepted to EUROMICRO '98 - Workshop for Software Process Improvement (pdf)
The success of software projects and the resulting software products are highly dependent on the initial stages of the life-cycle process – the inception and elaboration stages. The most critical success factors in improving the outcome of software projects have often been identified as being the requirements negotiation and the initial architecting and planing of the software system.
Not surprisingly, this area has thus received strong attention in the research community. It has, however, been hard to validate the effectiveness and feasibility of new or improved concepts because they are often only shown to work in a simplified and hypothesized project environment. Industry, on the other hand, has been cautious in adopting unproven ideas. This has led to a form of deadlock between those parties.
In the last two years, we had had the opportunity to observe dozens of software development teams in planing, specifying and building library related, real-world applications. This environment provided us with a unique way of introducing, validating and improving the life cycle process with new principles such as the WinWin approach to software development. This paper summarizes the lessons we have learned.
Added August 17th, 1998
USC-CSE-98-508 - Improving the Life-Cycle Process in Software Engineering Education (Sunita Chulani, Barry Boehm, Bert Steece)
Sunita Chulani, Barry Boehm, Bert Steece, "Improving the Life-Cycle Process in Software Engineering Education," IEEE Transactions on Software Engineering, July-August 1999, pp. 573-583 (pdf)
The COCOMO II.1997 software cost estimation model was originally formulated using behavioral analyses and an expert-judgement Delphi process to determine initial values of its cost drivers and scale factors. Using a multiple regression analysis approach, we then calibrated the model on a dataset consisting of 83 projects. The regression analysis produced results that occasionally contradicted the expert-judgement results: e.g. making a product more reusable caused it to be less expensive rather than more expensive to develop. These counter intuitive results were due to the fact that the COCOMO II database violated to some extent the following restrictions imposed by multiple linear regression [Briand92, Chulani98]:
(i) the number of datapoints should be large relative to the number of model parameters (i.e. there are many degrees of freedom). Unfortunately, collecting data has and continues to be one of the biggest challenges in the software estimation field. This is caused primarily by immature processes and management reluctance to release cost-related data.
(ii) no data items are missing. Data frequently contains missing information because the data collection activity has a limited budget or because of a lack of understanding of the data being reported.
(iii) there are no outliers. Extreme cases frequently occur in software engineering data because there is lack of precision in the data collection process.
(iv) the predictor variables (cost drivers and scale factors) are not highly correlated. Unfortunately, because cost data is historically rather than experimentally collected, correlations among the predictor variables are unavoidable.
USC-CSE-98-507 - Telecooperation Experience with the WinWin System (Alexander Egyed, Barry Boehm)
Alexander Egyed, Barry Boehm, "Telecooperation Experience with the WinWin System," Proceedings of the IFIP World Computer Conference, IFIP'98, pp. 37-46 (pdf)
WinWin is a telecooperation system supporting the definition of software-based applications as negotiated stakeholder win conditions. Our experience in using WinWin in defining over 30 digital library applications, including several telecooperation systems, is that it is important to supplement negotiation support systems such as WinWin with such capabilities as prototyping, tradeoff analysis tools, email, and videoconferencing. We also found that WinWin's social orientation around considering other stakeholders' win conditions has enabled stakeholders to achieve high levels of shared vision and mutual trust. Our subsequent experience in implementing the specified digital library systems in a rapidly changing web-based milieu indicated that achieving these social conditions among system stakeholders was more important than achieving precise requirements specifications, due to the need for team adaptability to requirements change. Finally, we found that the WinWin approach provides an effective set of methods of integrating ethical considerations into practical system definition processes via Rawls' stakeholder negotiation-based Theory of Justice.
USC-CSE-98-505 - Composing Components: How Does One Detect Potential Architectural Mismatches? (Cristina Gacek, Barry Boehm)
Nowadays, in order to be competitive, a developer's usage of Commercial off the Shelf (COTS), or Government off the Shelf (GOTS), packages has become a sine qua non, at times being an explicit requirement from the customer. The idea of simply plugging together various COTS packages and/or other existing parts results from the megaprogramming principles [Boehm and Scherlis 1992]. What people tend to trivialize is the side effects resulting from the plugging or composition of these subsystems. Some COTS vendors tend to preach that because their tool follows a specific standard, say CORBA, all composition problems disappear. Well, it actually is not that simple. Side effects resulting from the composition of subsystems are not just the result of different assumptions in communication methods by various subsystems, but the result from differences in various sorts of assumptions, such as the number of threads that are to execute concurrently, or even on the load imposed on certain resources. This problem is referred to as architectural mismatches [Garlan et al. 1995] [Abd-Allah 1996]. Some but not all of these architectural mismatches can be detected via domain architecture characteristics, such as mismatches in additional domain interface types (units, coordinate systems, frequencies), going beyond the general interface types in standards such as CORBA.
Other researchers have successfully approached reuse at the architectural level by limiting their assets not by domain, but rather by dealing with a specific architectural style. I.e., they support reuse based on limitations on the architectural characteristics of the various parts and resulting systems [Medvidovic et al. 1997] [Magee and Kramer 1996] [Allan and Garlan 1996]. This approach can be successful because it simply avoids the occurrence of architectural mismatches.
Our work addresses the importance of underlying architectural features in determining potential architectural mismatches while composing arbitrary components. We have devised a set of those features, which we call conceptual features [Abd-Allah 1996][Gacek 1997], and are building a model that uses them for detecting potential architectural mismatches. This underlying model has been built using Z [Spivey 1992].
USC-CSE-98-504 - Calibration Approach and Results of the COCOMO II Post-Architecture Model (Sunita Chulani, Bradford Clark, Barry Boehm, Bert Steece)
Sunita Chulani, Bradford Clark, Barry Boehm, Bert Steece, "Calibration Approach and Results of the COCOMO II Post-Architecture Model," Proceedings, ISPA '98 (pdf)
Nowadays, in order to be competitive, a developer's usage of Commercial off the Shelf (COTS), or Government off the Shelf (GOTS), packages has become a sine qua non, at times being an explicit requirement from the customer. The idea of simply plugging together various COTS packages and/or other existing parts results from the megaprogramming principles [Boehm
This paper describes our experience and results of the first calibration of the Post-Architecture model. The model determination process began with an expert Delphi process to determine apriori values for the Post-Architecture model parameters. A dataset of 83 projects was used in the multiple regression analysis. Projects with missing data or unexplainable anomalies were dropped. Model parameters that exhibited high correlation were consolidated. Multiple regression analysis was used to produce coefficients. These coefficients were used to adjust the previously assigned expert-determined model values. Stratification was used to improve model accuracy.
The resulting model produced estimates within 30% of the actuals 52% of the time for effort. Stratification by organization resulted in a model that produced estimates within 30% of the actuals 64% of the time for effort. It is therefore recommended that organizations using the model calibrate it using their own data. This increases model accuracy and produces a local optimum estimate for similar type projects.
The next calibration of COCOMO II will be done by using Bayesian techniques to incorporate prior knowledge and the sampling data information to determine the posteriori model.
USC-CSE-98-502 - Calibrating the COCOMO II Post-Architecture Model (Sunita Chulani, Bradford Clark, Barry Boehm)
Sunita Chulani, Bradford Clark, Barry Boehm, "Calibrating the COCOMO II Post-Architecture Model," Proceedings, ICSE 20, April 1998, pp. 477-480 (pdf)
The COCOMO II model was created to meet the need for a cost model that accounted for future software development practices. This resulted in the formulation of three submodels for cost estimation, one for composing applications, one for early lifecycle estimation and one for detailed estimation when the architecture of the product is understood. This paper describes the calibration procedures for the last model, Post-Architecture COCOMO II model, from eighty-three observations. The results of the multiple regression analysis and their implications are discussed. Future work includes further analysis of the Post-Architecture model, calibration of the other models, derivation of maintenance parameters, and refining the effort distribution for the model output.
USC-CSE-98-501 - Software Requirements Negotiation: Some Lessons Learned (Barry Boehm, Alexander Egyed)
Barry Boehm, Alexander Egyed, "Software Requirements Negotiation: Some Lessons Learned," Proceedings, ICSE 20, April 1998, pp. 503-506 (pdf)
Negotiating requirements is one of the first steps in any software system life cycle, but its results have probably the most significant impact on the system's value. However, the processes of requirements negotiation are not well understood. We have had the opportunity to capture and analyze requirements negotiation behavior for groups of projects developing library multimedia archive systems, using an instrumented version of the USC WinWin groupware system for requirements negotiation. Some of the more illuminating results were:
Most stakeholder Win Conditions were non-controversial (were not involved in Issues)
Negotiation activity varied by stakeholder role.
LCO package quality (measured by grading criteria) could be predicted by negotiation attributes.
WinWin increased cooperativeness, reduced friction, and helped focus on key issues.
USC-CSE-98-500 - A Comparison Study in Software Requirements Negotiation (Alexander Egyed, Barry Boehm)
Alexander Egyed, Barry Boehm, "A Comparison Study in Software Requirements Negotiation," Proceedings, INCOSE '98 (pdf)
In a period of two years, two rather independent experiments were conducted at the University of Southern California. In 1995, 23 three-person teams negotiated the requirements for a hypothetical library system. Then in 1996, 14 six-person teams negotiated the requirements for real multimedia related library systems.
A number of hypotheses were created to test how real software projects differ from hypothetical ones. Other hypotheses address differences in uniformity and repeatability.
The results indicate that repeatability in 1996 was even harder to achieve then in 1995 (Egyed-Boehm, 1996). Nevertheless, this paper presents some surprising commonalties between both years that indicate some areas of uniformity.
In both years, the same overall development process (spiral model) was followed, the same negotiation tools (WinWin System) were used, and the same people were doing the analysis of the findings. Thus, the comparison is less blurred by fundamental differences like terminology, process, etc.
USC-CSE-97-509 - Process Support of Software Product Lines (ISPW 10) (Barry Boehm)
Barry Boehm, "Process Support of Software Product Lines (ISPW 10)," Proceedings, ISPW 10, June 1996, pp. 2-6 (pdf)
The focus of ISPW 10 was on "Process Support of Software Product Lines." Much of the technology currently available to support the software process has focused on the process of developing and evolving a single software product. Increasingly, organizations are finding advantages in product-line software approaches, involving investments in domain engineering, product line architectures, and rapid applications composition with extensive use of commercial-off-the-shelf (COTS) and other reusable software assets. Recent books on software reuse and product line management [Jacobson-Griss-Jonsson, 1997; Poulin, 1997; Reifer, 1997] provide extensive evidence of the advantages: factors of 1.5 to 4 improvements in development time, factors of 1.5 to 6 in productivity, and factors of 2-10 in defect rates. This paper summarizes the original issues and major conclusions of the Workshop.
USC-CSE-97-508 - WinWin Requirements Negotiation Processes: A Multi-Project Analysis (Barry Boehm, Alexander Egyed)
Barry Boehm, Alexander Egyed, "WinWin Requirements Negotiation Processes: A Multi-Project Analysis," Proceedings, ICSP'98, pp. 125-136 (pdf)
Fifteen 6-member-teams were involved in negotiating requirements for multimedia software systems for the Library of the University of Southern California. The re-quirements negotiation used the Stakeholder WinWin success model and the USC WinWin negotiation model (Win Condition-Issue-Option-Agreement) and groupware system. The negotiated results were integrated into a Life Cycle Objectives (LCO) package for the project, including descriptions of the system's requirements, operational concept, architecture, life cycle plan, and feasibility rationale. These were subsequently elaborated into a Life Cycle Architecture package including a prototype; six of these were then implemented as products.
A number of hypotheses were formulated, tested, and evolved regarding the WinWin negotiation processes and their effectiveness in supporting the development of effective LCO packages, in satisfying Library clients, and in stimulating cooperation among stakeholders. Other hypotheses involved identification of WinWin improvements, relationships among negotiation strategies on LCO pack-age and project outcomes.
Barry Boehm, Bradford Clark, Sunita Chulani, "Calibration Results of COCOMOII.1997," presented at the SEPG-98 (pdf)
COCOMO II is an effort to update software cost estimation models, such as the 1981 COnstructive COst MOdel and its 1987 Ada COCOMO update. Both these and other 1980's cost models have experienced difficulties in estimating software projects of the 90s due to new practices such as non-sequential and rapid-development process models; reuse-driven approaches involving commercial-off-the-shelf (COTS) packages, reengineering, applications composition, and application generation capabilities; object-oriented ap proaches supported by distributed middleware; software process maturity effects and process-driven quality estimation. The COCOMO II research effort has developed new functional forms reflecting these practices, and is concentrated on developing a model well-suited for the 1990s and then annually updating it for the forthcoming years of the 21st Century.
The current COCOMO II.1997 has been calibrated to a dataset of 83 projects from a mix of Commercial, Aerospace, Government, and FFRDC organizations. The estimates of the 1997 calibrated model are within 30% of the actuals 52% of the times before stratific ation by organization; and within 30% of the actuals 64% of the times after stratification by organization.
The 1997 calibration results indicated that the following changes from COCOMO '81 to COCOMO II were successfully explaining sources of variation in the project data : Replacing the COCOMO '81 Development Modes by the 5 exponent drivers Precedentedness, Development Flexibility, Architecture/Risk Resolution, Team Cohesiveness, and CMM-based Process Maturity. Adding multiplicative cost drivers for Amount of Documentation and Multisite Development.
USC-CSE-97-504 - Developing Multimedia Applications with the WinWin Spiral Model (Barry Boehm, Alexander Egyed, Julie Kwan, Ray Madachy)
Barry Boehm, Alexander Egyed, Julie Kwan, Ray Madachy, "Developing Multimedia Applications with the WinWin Spiral Model," Proceedings, ESEC/FSE 97, Springer Verlag, 1997, pp. 20-39 (pdf)
Fifteen teams recently used the WinWin Spiral Model to perform the system engineering and architecting of a set of multimedia applications for the USC Library Information Systems. Six of the applications were then developed into an Initial Operational Capability. The teams consisted of USC graduate students in computer science. The applications involved extensions of USC's UNIX-based, text-oriented, client-server Library Information System to provide access to various multimedia archives (films, videos, photos, maps, manuscripts, etc.).
Each of the teams produced results which were on schedule and (with one exception) satisfactory to their various Library clients. This paper summarizes the WinWin Spiral Model approach taken by the teams, the experiences of the teams in dealing with project challenges, and the major lessons learned in applying the Model. Overall, the WinWin Spiral Model provided sufficient flexibility and discipline to produce successful results, but several improvements were identified to increase its cost-effectiveness and range of applicability.
USC-CSE-97-500 - Experiences in Software Cost Modeling (Barry Boehm)
Barry Boehm, "Experiences in Software Cost Modeling," Principles of Software Cost Estimating, Capers Jones, McGraw-Hill, 1998 (pdf)
My first exposure to software economics came on my first day in the software business, in June 1955 at General Dynamics in San Diego. My supervisor took me on a walking tour through the computer, an ERA 1103 which occupied most of a large room. His most memorable comment was, "Now listen, We're paying this computer six hundred dollars an hour, and we're paying you two hundred dollars an hour, and I want you to act accordingly." This created some good habits for me, such as careful desk checking, test planning, and analyzing before coding. But it also created some bad habits-a preoccupation with saving microseconds, patching object code, etc.-which were hard to unlearn when the balance of hardware and software costs began to tip the other way.
USC-CSE-96-509 - Lessons Learned on an Early Application Generator (Barry Boehm)
Barry Boehm, "Lessons Learned on an Early Application Generator" (pdf)
This paper discusses a set of experiences I had in developing ROCKET, an early application generator in the area of rocket flight mechanics at the Rand Corporation. It begins by describing a precursor system I worked on at General Dynamics. It also covers some experiences with the interactive ROCKET followon, and POGO, an early GUI builder. It concludes by relating these to the recent Megaprogramming and Domain Specific Software Architecture programs I was involved in at DARPA.
USC-CSE-96-508 - An Open Architecture for Software Process Asset Reuse (Barry Boehm, Steven Wolf)
Barry Boehm, Steven Wolf, "An Open Architecture for Software Process Asset Reuse," ISPW, 10th International Software Process Workshop (ISPW '96), p. 2 (pdf)
Beginning with the paper, "Software Processes are Software Too," [Osterweil, 1987], an attractive line of software process research has developed involving the exploitation of a duality between software products and software processes. This duality can be expressed as,
"If a given approach (disciplined programming, requirements definition and validation, reuse, risk management, peformance modeling) is good for software products, then its process counterpart is good for software processes."
Given that differences exist between software products and software processes (software products are executed by machines; software processes are executed by combinations of people and machines), this duality cannot be pushed too hard or applied unthinkingly.
USC-CSE-96-507 - Simulation and Modeling for Software Acquisition (SAMSA): Air Force Opportunities (Extended Report) (Barry Boehm, Walt Scacchi)
As indicated in the recent Air Force Scientific Advisory Board "New World Vistas" report [January 1996], "The future force will become effective and efficient through the use of information systems..." This particularly requires the Air Force to master the complexities of the rapidly evolving field of computer software, especially in the front end of the system life-cycle.
The need for better support technology for software acquisition was recognized by Mr. Lloyd Moseman, Deputy Assistant Secretary of the Air Force for Computers, Communications, and Support Systems. He also identified Modeling and Simulation (M&S) technology as a strong candidate for such support. M&S technology has been extremely valuable in the acquisition of the hardware parts of Air Force systems, but appears underutilized for software acquisition. Mr. Moseman commissioned USC-CSE to form a Blue Ribbon Panel to investigate the potential of M&S technology for software acquisition, and to develop a technology roadmap for creating and exploiting any promising technologies identified.
USC-CSE-96-505 - Models for Composing Heterogeneous Software Architectures (Ahmed Abd-Allah, Barry Boehm)
Ahmed Abd-Allah, Barry Boehm, "Models for Composing Heterogeneous Software Architectures" (pdf)
A persistent problem in software engineering is the problem of software composition. The emergence of software architectures and architectural styles has focused attention on a new set of abstractions with which we can create and compose software systems. We examine the problem of providing a model for the composition of different architectural styles within software systems, i.e. the problem of composing heterogeneous architectures. We describe a model of pure styles that is based on a uniform representation. We provide a disciplined approach for analyzing some key aspects of architectural composition, and show the conditions under which systems will fail to be composed.
USC-CSE-96-504 - Analysis of Software Requirements Negotiation Behavior Patterns (Alexander Egyed, Barry Boehm)
Alexander Egyed, Barry Boehm, "Analysis of Software Requirements Negotiation Behavior Patterns," Proceedings, INCOSE '97 (pdf)
Roughly 35 three-person teams played the roles of user, customer, and developer in negotiating the requirements of a library information system. Each team was provided with a suggested set of stakeholder goals and implementation options, but were encouraged to exercise creativity in expanding the stakeholder goals and in creating options for negotiating an eventually satisfactory set of requirements.
The teams consisted of students in a first-year graduate course in software engineering at USC. They were provided with training in the Theory W (win-win) approach to requirements determination and the associated USC WinWin groupware support system. They were required to complete the assignment in two weeks.
Data was collected on the negotiation process and results, with 23 projects providing sufficiently complete and comparable data for analysis. A number of hypotheses were formulated about the results, e.g. that the uniform set of initial conditions would lead to uniform results. This paper summarizes the data analysis, which shows that expectations of uniform group behavior were generally not realized.
USC-CSE-96-503 - An Early Applications Generator and Other Recollections (Barry Boehm)
Barry Boehm, "An Early Applications Generator and Other Recollections," In the Beginning: Recollections of Software Pioneers, R. Glass, IEEE, 1998, pp. 67-97 (pdf)
In this paper, I'll focus primarily on a set of experiences I had in developing an early application generator in the area of rocket flight mechanics. But I'll begin with some other recollections to indicate what led up to this work. And I'll end with recollections of some of the software experiences I've had since.
USC-CSE-96-502 - The WinWin Requirements Negotiation System: A Model-Driven Approach (Ming June Lee, Barry Boehm)
Ming June Lee, Barry Boehm, "The WinWin Requirements Negotiation System: A Model-Driven Approach" (pdf)
Requirements Engineering constitutes an important part of Software Engineering. The USC WinWin requirements negotiation system addresses critical issues in requirements engineering including (1) multi-stakeholder considerations, (2) change management, and (3) groupware support. This paper presents our current research efforts on constructing and reconciling several formal and semi-formal models of the system and its operations, including inter-artifact relationships, artifact life cycles, and equilibrium model. It concentrates on determining the relationships among the various models or views of the WinWin requirements engineering process.
Barry Boehm, Hoh In, "Software Cost Option Strategy Tool (S-COST)," COMPSAC '96, the 20th International Computer Software and Application Conference, 1996, pp. 15-20 (pdf)
The resolution process of cost conflicts among requirements is complex because of highly collaborative and coordinated processes, complex dependencies, and exponentially increasing option space. This paper describes an exploratory knowledge-based tool (called "S-COST") for assisting stakeholders to surface huge option space and diagnose risks of each option.
The S-COST operates in the context of the USC-CSE WinWin system (a groupware support system for determining software and system requirements as negotiated win conditions), QARCC (a support system for identifying conflicts in quality requirements), and COCOMO (COnstructive COst estimation MOdel).
USC-CSE-95-509 - The WinWin Spiral Software Process Model (Barry Boehm, Prasanta Bose)
Barry Boehm, Prasanta Bose, "The WinWin Spiral Software Process Model," Proceedings, 3rd ICSP, 1994 (pdf)
A primary difficulty in applying the Spiral model has been the lack of explicit process guidance in determining the prospective system's objectives, constraints, and alternatives that get elaborated in each cycle. This paper presents an extension of the spiral model, called the WinWin process model, which uses the Theory W (win-win) approach to converge on a system's next level objectives, constraints, and alternatives. The WinWin Spiral model explicitly addresses the need for concurrent analysis, risk resolution, definition, and elaboration of both the software product and software process in a collaborative manner. The paper discusses an application of the model, identifies the need for support systems to facilitate cost-effective realization of the model, and describes bootstrap experiments that lead to identifying key capabilities of support systems for the model. The key elements of the evolved WinWin support system developed to meet the needs are also discussed.
USC-CSE-95-508 - Cost Models for Future Software Life Cycle Processes: COCOMO 2.0 (Barry Boehm, Bradford Clark, Ellis Horowitz, Chris Westland, Ray Madachy, Richard Selby)
Barry Boehm, Bradford Clark, Ellis Horowitz, Chris Westland, Ray Madachy, Richard Selby, "Cost Models for Future Software Life Cycle Processes: COCOMO 2.0," Annals of Software Engineering, Springer Netherlands, Volume 1, Number 1, December, 1995, pp. 57-94 (pdf)
Current software cost estimation models, such as the 1981 Constructive Cost Model (COCOMO) for software cost estimation and its 1987 Ada COCOMO update, have been experiencing increasing difficulties in estimating the costs of software developed to new life cycle processes and capabilities. These include non-sequential and rapid-development process models; reuse-driven approaches involving commercial off the shelf (COTS) packages, reengineering, applications composition, and applications generation capabilities; object-oriented approaches supported by distributed middleware; and software process maturity initiatives.
This paper summarizes research in deriving a baseline COCOMO 2.0 model tailored to these new forms of software development, including rationales for the model decisions. The major new modeling capabilities of COCOMO 2.0 are a tailorable family of software sizing models, involving Object Points, Function Points, and Source Lines of Code; nonlinear models for software reuse and reengineering; an exponent-driver approach for modeling relative software diseconomies of scale; and several additions, deletions, and updates to previous COCOMO effort-multiplier cost drivers. This model is serving as a framework for an extensive current data collection and analysis effort to further refine and calibrate the model’s estimation capabilities.
USC-CSE-95-507 - Anchoring the Software Process (Barry Boehm)
Barry Boehm, "Anchoring the Software Process," IEEE Software, Volume 13, Issue 4, July 1996, pp. 73-82 (pdf)
The current proliferation of software process models provides flexibility for organizations to deal with the unavoidably wide variety of software project situations, cultures, and environments. But it weakens their defenses against some common sources of project failure, and leaves them with no common anchor points around which to plan and control. This article identifies three milestones -- Life Cycle Objectives, Life Cycle Architecture, and Initial Operational Capability -- which can serve as these common anchor points. It also discusses why the presence or absence of these three milestones or their equivalents is a critical success factor, particularly for large software projects, but for other software projects as well.
USC-CSE-95-506 - Aids for Identifying Conflicts Among Quality Requirements (Barry Boehm, Hoh Peter In)
Barry Boehm, Hoh Peter In, "Aids for Identifying Conflicts Among Quality Requirements," Proceedings, ICRE-96, and IEEE Software, March 1996 (pdf)
One of the biggest risks in software requirements engineering is the risk of over emphasizing one quality attribute requirement (e.g., performance) at the expense of others at least as important (e.g., evolvability and portability). This paper describes an exploratory knowledge-based tool for identifying potential quality attribute risks and conflicts early in the software/system life cycle.
The Quality Attribute Risk and Conflict Consultant (QARCC) examines the quality attribute tradeoffs involved in software architecture and process strategies (e.g., one can improve portability via a layered architecture, but usually at some cost in performance). It operates in the context of the USC-CSE WinWin system, a groupware support system for determining software and system requirements as negotiated win conditions.
USC-CSE-95-503 - Reasoning about the Composition of Heterogeneous Architectures (Ahmed Abd-Allah, Barry Boehm)
Ahmed Abd-Allah, Barry Boehm, "Reasoning about the Composition of Heterogeneous Architectures," Qualifying Proposal (pdf)
A persistent problem in software engineering is how to put software systems together out of smaller subsystems: the problem of software composition. The emergence of software architectures and architectural styles has focused attention on a new set of abstractions with which we can create and compose software systems. We examine the problem of providing a model for the composition of different architectural styles within software systems, i.e. the problem of composing heterogeneous architectures. We describe a model of pure styles and of their composition. We provide a disciplined approach to the process of architectural composition, and techniques for using the approach to determine architectural constraints and the conditions under which systems will fail to be composed.
USC-CSE-95-500 - On the Definition of Software System Architecture (Cristina Gacek, Ahmed Abd-Allah, Bradford Clark, Barry Boehm)
Cristina Gacek, Ahmed Abd-Allah, Bradford Clark, Barry Boehm, "On the Definition of Software System Architecture," Proceedings, First International Workshop on Architectures for Software Systems, in Cooperation with the 17th International Conference on Software Engineering, D. Garlan (ed.), Seattle, WA, April 24-25, 1995, pp. 85-95 (pdf)
Although several definitions of "software architecture" have been presented, none of them to date enable a reviewer confronted with a complex of diagrams and symbols to determine whether it is an architecture for a system or not. We present a definition of "software system architecture" which provides a set of criteria for mak ing this determination. It is based on making the architectural rationale a first-class citizen in the definition, and on requiring the rationale to ensure that the architecture's components, connections, and constraints define a system that will satisfy a set of defined stakeholder needs for the system.
USC-CSE-95-499 - Software Process Architectures (Barry Boehm)
Barry Boehm, "Software Process Architectures," Proceedings of the First International Workshop on Architectures For Software Systems, Seattle, WA (pdf)
Beginning with the paper, "Software Processes are Software Too," [Osterweil, 1987], an attractive line of software process research has developed involving the exploitation of a duality between software products and software processes. This duality can be expressed as,
"If a given approach (disciplined programming, requirements definition and validation, reuse, risk management, peformance modeling) is good for software products, then its process counterpart is good for software processes."
Given that differences exist between software products and software processes (software products are executed by machines; software processes are executed by combinations of people and machines), this duality cannot be pushed too hard or applied unthinkingly. But, as seen in a number of papers in the series of International Conferences on the Software Process, this duality has provided useful insights and results in such process areas as process life-cycles [Feiler-Humphrey, 1993], process requirements [Dowson, 1993], process validation [Cook-Wolf, 1994], and process evolution [Bandinelli et al., 1994].
This paper addresses the hypothesis, "If architectures and architecting are good for software products, then their process architecture counterparts will be good for software processes." The following sections address major software product architecture subarenas (architectural elements; architectural styles; system architectures; domain and product line architectures; and enterprise architectures), and elaborate on their software process architecture counterparts.
USC-CSE-94-505 - Some Critical Success Factors for Knowledge Based Software Engineering Applications (Barry Boehm, Prasanta Bose, Greg Toth)
Barry Boehm, Prasanta Bose, Greg Toth, "Some Critical Success Factors for Knowledge Based Software Engineering Applications," Proceedings of the International Workshop on Software Engineering Education, Sorrento, Italy, May, 1994 (pdf)
In the Spring of 1993, the authors participated in a USC seminar course in Knowledge Based Software Engineering (KBSE) which involved the development of ten prototype KBSE applications. Evaluations of these prototype applications indicated a considerable range of relative utility to practicing software engineers. For potential discussion at the SE/ AI workshop, we offer below an analysis of some critical success factors (CSF's) distinguishing the prototypes with more and less utility.
The authors' roles in this situation extended the AI user/ provider model to cover two additional bridge roles (technology advocates and technology receptors) determined by the Software Engineering Institute [Fowler-Rifkin, 1990] to be significant facilitators in software technology transition.
Prasanta Bose, whose primary field has been AI and who served as the course's associate instructor, functioned as a Technology Advocate in advancing AI capabilities for application to software engineering (SE) problems. Barry Boehm, whose primary field has been SE and who served as the course's instructor, functioned as a Technology Receptor interested in finding new KB approaches to SE problems by knowledge mining and knowledge engineering of SE domain experts. Greg Toth represented both ends of the technology transition chain: as a course student producing a prototype KBSE [Toth,1993]; and as a Northrop software manager interested in new tools for Northrop software engineering applications.
Added June 25th, 2008
USC-CSE-94-503 - Software Requirements Negotiation and Renegotiation Aids: A Theory-W Based Spiral Approach (Barry Boehm, Ming June Lee, Prasanta Bose, Ellis Horowitz)
A major problem in requirements engineering is obtaining requirements that address the concerns of multiple stakeholders. An approach to such a problem is the Theory-W based Spiral Model. One key element of this model is stakeholder collaboration and negotiation to obtain win-win requirements. This paper focuses on the problem of developing a support system for such a model. In particular, it identifies needs and capabilities required to address the problem of negotiation and renegotiation that arises when the model is applied to incremental requirements engineering. The paper formulates elements of the support system, called WinWin, for providing such capabilities. These elements were determined by experimenting with versions of WinWin and understanding their merits and deficiencies. The key elements of WinWin are described and their use in incremental requirements engineering are demonstrated, using an example renegotiation scenario from the domain of software engineering environments for satellite ground stations.
USC-CSE-94-502 - Humans and Process Frameworks: Some Critical Process Elements (Barry Boehm, Prasanta Bose)
Barry Boehm, Prasanta Bose, "Humans and Process Frameworks: Some Critical Process Elements," Proceedings, Software Process Workshop, 1994 (pdf)
Successful engineering of complex software systems require humans to engage collaboratively in multiple critical process elements. This paper identifies those necessary process elements and defines WinWin, a collaborative process model that addresses the process elements. It briefly describes a process support system for the WinWin model.
USC-CSE-94-501 - A Collaborative Spiral Software Process Model Based on Theory W (Barry Boehm, Prasanta Bose)
Barry Boehm, Prasanta Bose, "A Collaborative Spiral Software Process Model Based on Theory W," Proceedings, Third International Software Process Conference, 1994, pp. 59-68 (pdf)
A primary difficulty in applying the spiral model has been the lack of explicit process guidance in determining the prospective system's objectives, constraints, and alternatives that get elaborated in each cycle. This paper presents an extension of the spiral model, called the Next Generation Process Model (NGPM), which uses the Theory W (win-win) approach [Boehm-Ross, 1989] to converge on a system's next-level objectives, constraints, and alternatives. The refined Spiral Model explicitly addresses the need for concurrent analysis, risk resolution, definition, and elaboration of both the software product and the software process in a collaborative manner. This paper also describes some of the key elements of the support system developed based on the model and refined through experiments with it.
USC-CSE-94-500 - Critical Success Factors for Knowledge Based Software Engineering Applications (Barry Boehm, Prasanta Bose)
Barry Boehm, Prasanta Bose, "Critical Success Factors for Knowledge Based Software Engineering Applications," Automated Software Engineering, Springer Netherlands, Volume 2, Number 3, September, 1995, pp. 193-202 (pdf)
Ten prototype knowledge based software engineering (KBSE) applications were recently developed in a USC graduate course. These were expert-system applications falling into the Activity Coordination portion of the KBSA paradigm [Green et. al.,1983] rather than into the automatic program generation portion. The KBSE development guidelines for the prototypes included the primary critical success factor (CSF) heuristics cited in such references as [Waterman, 1986], [Jackson, 1990], and [Kelly, 1991] for identifying potentially successful expert systems applications. The resulting applications could be grouped into three categories, as follows:
i) Knowledge based process assistance
ii) Knowledge based software architecture and reuse assistance
USC-CSE-94-499 - Focused Workshop on Software Architectures: Issue Paper (Cristina Gacek, Ahmed Abd-Allah, Bradford Clark, Barry Boehm)
Cristina Gacek, Ahmed Abd-Allah, Bradford Clark, Barry Boehm, "Focused Workshop on Software Architectures: Issue Paper," Knowledge Summary of the USC-CSE Focused Workshop on Software Reuse, Center for Software Engineering, University of Southern California, Los Angeles, CA, June 6-9, 1994 (pdf)
The Center for Software Engineering (CSE) at USC is currently involved in research on software architecting and architectures. The main objective of this workshop is to calibrate the CSE architecture research strategy to the Center Affiliates’ needs and priorities. This includes identifying and prioritizing the most critical architecture research issues; clarifying the nature of, and defining the interactions between the architecture subdisciplines (representation, style, domain specific software architectures, process, and infrastructure); and calibrating the maturity of emerging architecture infrastructure technologies with respect to Affiliate-scale needs.
This issue paper is the first step in the Focused Workshop process. It summarizes the CSE architecture research strategy elements and positions, and identifies candidate high-priority issues. The next steps in the process involve feedback from Affiliates on the strategy and issues via position papers and workshop discussions. We also plan to achieve the objectives of clarifying and calibrating the architecture state-of-the-art and state-of-the-practice via workshop presentations and discussions.
The strategies in the paper have already been influenced strongly by the USC-CSE Affiliates via the results of the February 1994 Executive Workshop on Information Architectures and Software Product Line Management.
Added June 24th, 2008
USC-CSE-93-502 - Software Process Evolution: No Process Is an Island (Barry Boehm)
Barry Boehm, "Software Process Evolution: No Process Is an Island," position paper (pdf)
This position paper addresses some practical concerns in software process evolution, drawing primarily from experiences in the U.S. Department of Defense (DoD) and TRW. It focuses on the following three position statements:
1. The phrase "software process" is semantically overloaded. This causes a good deal of confusion and wheel-spinning. A top-level software process taxonomy is provided to help clarify the situation.
2. Evolution concerns vary by process subclass. Sources of variation include stimuli for evolution, and the mix of technical and cultural considerations involved in implementing evolution.
3. No process is an island. The most serious software process difficulties arise when a particular software process is developed and executed in isolation from concurrently evolving related processes. Some approaches for addressing heterogeneous process interactions are proposed.
Added June 25th, 2008
USC-CSE-93-501 - Software Requirements as Negotiated Win Conditions (Barry Boehm, Prasanta Bose, Ellis Horowitz, Ming June Lee)
Current processes and support systems for software requirements determination and analysis often neglect critical needs of important classes of stakeholders and limit themselves to concerns of the developers, users and customers. Besides developers, customers, and users, these stakeholders can include maintainers, interfacers, testers, product line managers, and sometimes members of the general public.
This paper describes the results to date in researching and prototyping a Next Generation Process Model (NGPM) and support system (NGPSS) which directly addresses these issues. The NGPM emphasizes collaborative processes, involving all of the significant constituents with a stake in the software product. Its conceptual basis is a set of Theory W (win-win) extensions to the Spiral Model of software development.
Added June 25th, 2008
USC-CSE-93-499 - Next-Generation Software Processes and Their Environment Support (Barry Boehm, Prasanta Bose, Ellis Horowitz, Ming June Lee)
Barry Boehm, Prasanta Bose, Ellis Horowitz, Ming June Lee, "Next-Generation Software Processes and Their Environment Support," TRW Systems Integration Group Technology Review, Volume 2, Number 1, Summer 1994 (pdf)
The Next Generation Process Model (NGPM) uses the Theory W steps of win condition identification and negotiation to determine the objectives, constraints, and alternatives required to initiate each cycle of the Spiral Model of software development. The Next Generation Process Support System (NGPSS) is an evolving prototype of a groupware support environment for the NGPM. To test the scalability and process support capabilities of the initial NGPSS-0 prototype, we performed a bootstrap experiment using the NGPSS-0 to: 1) identify NGPSS user, customer, developer, and system engineer win conditions for future versions of the NGPSS, 2) identify win condition conflicts, and 3) resolve the conflicts into points of agreement which then transform into objectives, constraints, and alternatives for NGPSS. The experiment partially confirmed each of the four primary experimental hypotheses. These covered the adequacy of NGPSS-0; the comparability of NGPSS win conditions with a previous set of TRW software environment win conditions; the adequacy of win conditions as generators of Spiral Model objectives, constraints, and alternatives; and the adequacy of the bootstrap process in defining the next increment of NGPSS.
Added June 25th, 2008
USC-CSE-93-498 - Next-Generation Software Processes and Their Environment Support (Barry Boehm, Prasanta Bose, Ellis Horowitz, Walter Scacchi, Salah Bendifallah, Azad Madni)
Barry Boehm, Prasanta Bose, Ellis Horowitz, Walter Scacchi, Salah Bendifallah, Azad Madni, "Next-Generation Software Processes and Their Environment Support," Proceedings, USC Center for Software Engineering Inaugural Convocation, June 1993 (pdf)
This paper discusses the shortfalls involved with current software process models, and describes a USC research project to develop a Next-Generation Process Model (NGPMl ) addressing these shortfalls. The NGPM emphasizes collaborative software processes. Its conceptual basis is a set of Theory W (win-win) extensions to the Sprial Model of software development.
The paper also discusses concepts and approaches for developing a Next-Generation Process Support System (NGPSS), a groupware-oriented support capability for the NGPM. It describes an approach for collaborative win-condition elicitation and resolution with respect to a prospective software product's constituents or stakeholders (users, customers, developers, maintainers, interfacers, etc.). This approach is based the Theory W steps of win-condition identification; expectations management; collaborative creation, analysis, and negotiation of win-win solutions; and management of win-lose or lose-lose risks.
The NGPSS is elaborated into a candidate set of of user interface screens and collaborative support capabilities, based on Perceptronics' Computer Aided Concurrent Engineering (CACEIPM®2 ) toolset. A candidate top-level NGPSS architecture is also presented, including an approach for integrating the NGPSS capabilities into current and evolving software environment capabilites.
Added June 25th, 2008
USC-CSE-92-500 - Megaprogramming (Barry Boehm, William L. Scherlis)
Barry Boehm, William L. Scherlis, "Megaprogramming," Proceedings of the DARPA Software Technology Conference, Los Angeles, California, April 28-30, 1992, Meridien Corp., Arlington, Virginia, 1992 (pdf)
"Megaprogramming" refers to the practice of building and evolving computer software component by component. Megaprogramming builds on the processes and technologies of software reuse, software engineering environments, software architecture engineering, and application generation in order to provide a component-oriented product-line approach to software development In the product line approach, management incentives and technology support can be structured to favor the aggregate return on investment over a set of related software products, even when certain portions of the investment-whose benefits are realized across the product line-may be higher than they would be if products were managed individually.
Particular aspects of the megaprogramming approach are in use in specific sectors, with significant impact. The merits of architecture-oriented design and reuse of software assets are well understood. Experience has been gained, starting in the 1950's with user-group component libraries such as the IBM SHARE (Society to Help Avoid Redundant Effort) library, and through seminal papers on mass-produced software components such as [McIlroy1968], to major publications summarizing the state of the art and state of the practice in software reuse [Freeman1987, Tracz1988, Biggerstaffl989, Cusumanol991, STARS-Reusel991].
More often than not, however, the potential of reuse and related practices and technologies has not been realized. Reuse has been discussed and attempted many times as a solution for software productivity and quality problems. Specific features have been distinguished that characterize successful reuse, and it is around these features that the megaprogramming approach is based. Megaprogramming is not a silver bullet; it is a coordinated approach to a broad range of management and technology facets of software engineering practice. This paper examines these management and technology facets in the light of an analysis of economic factors and incentives.
Added June 24th, 2008
USC-CSE-91-501 - Economic Analysis of Software Technology Investments (Barry Boehm)
Barry Boehm, "Economic Analysis of Software Technology Investments," Analytical Methods in Software Engineering Economics, T. Gulledge and W. Hutzler (ed.), Springer-Verlag, 1993 (pdf)
Many large organizations are finding that:
Software technology is increasingly critical to their future organizational performance.
Organizational expenditures on software are increasing.
Investments in software technology provide opportunities to reduce software costs and increase organizational performance.
The U.S. Department of Defense (DoD) is one such organization. It has embarked on the development of a DoD Software Technology Strategy (SWTS)[Boehm91a] to:
Identify its current and future software technology needs.
Analyze and adjust its current software technology investment portfolio to better meet DoD needs.
Formulate alternative DoD software technology investment portfolios, and analyze them with respect to DoD needs and estimated cost savings.
This paper summarizes one of several analyses undertaken to evaluate alternative DoD software technology investment portfolios. The analysis estimates the DoD software cost savings likely to result from alternative levels of DoD investment and calculates the resulting estimated returns on investment (ROI).
The dollar figures used in this paper represent current and proposed alternative technology investment and savings figures used at one stage of the development of the SWTS. At this point, they are representative of SWTS data and conclusions, but not necessarily accurate with respect to the final figures to be used in the SWTS.
Added June 24th, 2008
USC-CSE-91-500 - Software Risk Management: Principles and Practices (Barry Boehm)
Barry Boehm, "Software Risk Management: Principles and Practices," original version of IEEE Software, Volume 8, Issue 1, January 1991, pp. 32-41 (pdf)
Like many fields in their early stages, the software field has had its share of project disasters: the software equivalents of Beauvais Cathedral, the S.S. Titanic, and the "Galloping Gertie" Tacoma Narrows Bridge. The frequency of these disaster projects is a serious concern: a recent survey of 600 firms indicated that 35% of them had at least one "runaway" software project [I].
Most post-mortems of these software disaster projects have indicated that their problems would have been avoided or strongly reduced if there had been an explicit early concern with identifying and resolving their high-risk elements. Frequently, these projects were swept along by a tide of optimistic enthusiasm during their early phases, which caused them to miss some clear signals of high-risk issues which proved to be the project's downfall later.
Enthusiasm for new software capabilities is a good thing. But it needs to be tempered with a concern for early identification and resolution of a project's high-risk elements, so that people can get these resolved early and then focus their enthusiasm and energy on the positive aspects of their software product.
Added June 24th, 2008
USC-CSE-89-504 - Experiences with the Spiral Model as A Process Model Generator (Barry Boehm, Frank Belz)
Barry Boehm, Frank Belz, "Experiences with the Spiral Model as A Process Model Generator," an expanded version of Proceedings of the 5th International Software Process Workshop, 1989. Experience with Software Process Models, October 10-13, 1989, pp. 43-45 (pdf)
Many of the problems on software projects arise from mismatches between the process model used by the project and the project's real-world process drivers, such as budget, schedule, and available commercial off-the-shelf (COTS) software. The primary process modeling approach to date for avoiding these mismatches has been to try to develop the perfect process model: one which will work well for any combination of process drivers.
Our position is that a good process model generator would be nearly as effective as the perfect process model, and much more likely to be achievable. A process model generator is a technique which operates on a project's process drivers as inputs to produce a process model for the project which is tailored to its particular process drivers.
We have had several experiences in using the Spiral Model [Boehm, 19881 as a process model generator. Our initial experience in generating a process model for the TRW Quantum Leap program was reported in the previous workshop [Boehm-Belz, 19883. Subsequent experiences have generated some significantly different process models for avionics, command-control, exploratory research projects, and small fourth-generation language (4GL) based systems.
Below, we provide a short summary of the use of the spiral model as a process model generator, and a summary of the various process model generation experiences in terms of a Process Model Decision Table showing the critical process driver conditions under which the most familiar process models (e.g., waterfall [Royce, 1970], evolutionary development [McCracken-Jackson, 1982], and transform [Balzer-Cheatham-Green, 1988]) are the appropriate choice of a process model for a particular software project.
Added June 18th, 2008
USC-CSE-89-503 - Ada COCOMO and the Ada Process Model (Barry Boehm, Walker Royce)
Barry Boehm, Walker Royce, "Ada COCOMO and the Ada Process Model," Proceedings, Fifth COCOMO Users' Group Meeting, Software Engineering Institute, Pittsburgh, PA, November 1989 (pdf)
The original version of the Constructive Cost Model (COCOMO) [Boehm, 1981] was calibrated to 56 software development projects, and validated on 7 subsequent projects. On these projects, the COCOMO development effort estimates were accurate within 20% of the project actuals, about 70% of the time.
Subsequently, COCOMO has done approximately as well on most carefully collected sets of project data [Boehm, 1985; Jopen, 1985; Goudy, 1987]. In some cases, COCOMO has exhibited a systematic bias, but has done approximately as well once recalibrated to the specific environment [Boehm, 1985; Miyazaki-Mori, 1985; Marouane-Mili, 1989]. It should be noted that there are also some sets of project data for which COCOMO has been considerably less accurate [Kemerer,1987; Martin, 1988].
Recently, three software development approaches have motivated the development of a revised version of COCOMO: the use of the Ada programming language, the use of incremental development, and the use of an Ada process model capitalizing on the strengths of Ada to improve the efficiency of software development. This paper presents the portions of the revised Ada COCOMO dealing with the effects of Ada and the Ada process model.The remainder of this section of the paper discusses the objectives of Ada COCOMO. Section 2 describes the Ada Process Model and its overall effects on software development effort and schedule. Section 3 presents the structure and features of Ada COCOMO, and discusses the rationale behind the changes made from the earlier version of COCOMO (called "standard COCOMO" in the remainder of the paper). Section 4 summarizes the current status of Ada COCOMO, including its calibration to date and its currently available implementations; and Section 5 presents the resulting conclusions.
Added June 18th, 2008
USC-CSE-89-501 - Rapid Prototyping, Risk Management, 2167, and the Ada Process Model (Barry Boehm)
Barry Boehm, "Rapid Prototyping, Risk Management, 2167, and the Ada Process Model," Software Risk Management, 1989, pp. 47-52 (pdf)
DoD-STD-2167A offers sufficient degrees of freedom to appropriately accommodate rapid prototyping into a software development, given that one has an appropriate process model to substitute for the waterfall model, which otherwise tends to be used as the default implementation of 2167A.
TRW has been developing an Ada Process Model which incorporates the strengths of Ada, rapid prototyping, risk management, and the Spiral Model into a model which can be expressed as a tailored version of DoD-STD-2167A. We have also been developing an Ada version of the Constructive Cost Model (COCOMO) for software cost estimation, which reflects the added efficiencies of using Ada and the Ada Process Model.
Barry Boehm, Rony Ross, "Theory-W Software Project Management Principles and Examples," IEEE Transactions on Software Engineering, Volume 15, Issue 7, July 1989, pp. 902-916 (pdf)
A software project management theory is presented called Theory W: make everyone a winner. The authors explain the key steps and guidelines underlying the Theory W statement and its two subsidiary principles: plan the flight and fly the plan; and, identify and manage your risks. Theory W's fundamental principle holds that software project managers will be fully successful if and only if they make winners of all the other participants in the software process: superiors, subordinates, customers, users, maintainers, etc. Theory W characterizes a manager's primary role as a negotiator between his various constituencies, and a packager of project solutions with win conditions for all parties. Beyond this, the manager is also a goal-setter, a monitor of progress towards goals, and an activist in seeking out day-to-day win-lose or lose-lose project conflicts confronting them, and changing them into win-win situations. Several examples illustrate the application of Theory W. An extensive case study is presented and analyzed: the attempt to introduce new information systems to a large industrial corporation in an emerging nation. The analysis shows that Theory W and its subsidiary principles do an effective job both in explaining why the project encountered problems, and in prescribing ways in which the problems could have been avoided.
Added November 11th, 2005
USC-CSE-89-499 - Software Factories in the USA (Barry Boehm)
Software factory technology and practice in the USA has recently accelerated rapidly with the boom in the CASE (Computer Aided Software Engineering) market. Concerns about long-range international competitiveness caused most large USA corporations to focus on corporate restructuring to achieve leaner, more adaptive modes of operation. Concerns with Federal deficits caused similar pressures on USA Government organizations. In the data processing area, this frequently led to downstaffing and attempts to more effectively capitalize software development and maintenance via personal workstations, improved practices and procedures, and CASE tools. This short survey provides a summary of the primary elements of the USA software factory situation in 1989, and a representative set of software factory lessons learned at TRW.
Added June 18th, 2008
USC-CSE-88-502 - Applying Process Programming to the Spiral Model (Barry Boehm, Frank Belz)
The primary thesis of this position paper is that process programming is analogous to programming in an key respect not previously emphasized: that it will proceed more effectively if preceded by a set of activities to determine the requirements, architecture, and design of the process.
Added June 18th, 2008
USC-CSE-88-501 - What We Really Need Are Process Model Generators (Barry Boehm)
A good many of the problems on software projects arise from mismatches between the process model used by the project and the project's real-world process drivers: budget, schedule, available commercial off-the-shelf (COTS) software, customer standards, user mission or technology uncertainties, etc. The primary process modeling approach to date for avoiding these mismatches has been to try to develop the perfect process model: one which will work well for any combination of process drivers.
Our position in this paper is that a good process model generator would be nearly as effective as the perfect process model, and much more likely to be achievable. A process model generator is a technique which operates on a project's process drivers as inputs to produce a process model for the project which is tailored to its particular process drivers.
Added June 18th, 2008
USC-CSE-88-500 - A Spiral Model of Software Development and Enhancement (Barry Boehm)
Barry Boehm, "A Spiral Model of Software Development and Enhancement," IEEE Computer, Volume 21, Issue 5, May 1988, pp. 61-72 (pdf)
A short description is given of software process models and the issues they address. An outline is given of the process steps involved in the spiral model, an evolving risk-driven approach that provides a framework for guiding the software process, and its application to a software project is shown. A summary is given of the primary advantages and implications involved in using the spiral model and the primary difficulties in using it at its current incomplete level of elaboration.
Added November 11th, 2005
USC-CSE-88-499 - Theory-W Software Project Management: A Case Study (Barry Boehm, Rony Ross)
The search for a single unifying principle to guide software project management has been relatively unrewarding to date. Most candidate principles are either insufficiently general to apply in many situations, or so general that they provide no useful specific guidance.
This paper presents a candidate unifying principle which appears to do somewhat better. Reflecting various alphabetical management theories (X, Y, Z), it is called the Theory W approach to software project management.
Theory W: Make Everyone a Winner
The paper explains the Theory W principle and its two subsidiary principles: Plan the flight and fly the plan; and, Identify and manage your risks.
To test the practicability of Theory W, a case study is presented and analyzed: the attempt to introduce new information systems to a large industrial corporation in an emerging nation. The case may seem unique, yet it is typical. The analysis shows that Theory W and its subsidiary principles do an effective job both in explaining why the project encountered problems, and in prescribing ways in which the problems could have been avoided.
Barry Boehm, "Improving Software Productivity," IEEE Computer, Volume 20, Issue 9, September 1987, pp. 43-57 (pdf)
Computer hardware productivity continues to increase by leaps and bounds, while software productivity seems to be barely holding its own. Central processing units, random access memories, and mass memories improve their price-performance ratios by orders of magnitude per decade, while software projects continue to grind out production-engineered code at the same old rate of one to two delivered lines of code per man-hour.
Yet, if software is judged by the same standards as hardware, its productivity looks pretty good. One can produce a million copies of Lotus 1-2-3 at least as cheaply as a million copies of the Intel 286. Database management systems that cost $5 million 20 years ago can now be purchased for $99.95.
The commodity for which productivity has been slow to increase is custom software. Clearly, if you want to improve your organization's software price-performance, one major principle is "Don't build custom software where mass-produced software will satisfy your needs. " However, even with custom software, a great deal is known about how to improve its productivity, and even increasing productivity by a factor of 2 will make a significant difference for most organizations.
This article discusses avenues of improving productivity for both custom and mass-produced software. Its main sections cover the following topics:
• The importance of improving software productivity: some national, international, and organizational trends indicating the significance of improving software productivity.
• Measuring software productivity: some of the pitfalls and paradoxes in defining and measuring software productivity and how best to deal with them.
• Analyzing software productivity: identifying factors that have a strong productivity influence and those that have relatively little influence, using such concepts as software productivity ranges, the software value chain, and the software productivity opportunity tree.
• Improving software productivity: using the opportunity tree as a framework for describing specific productivity improvement steps and their potential payoffs.
• Software productivity trends and conclusions.
Added June 18th, 2008
USC-CSE-87-501 - Next Generation Software Environment: Principles, Problems, and Research (Richard N. Taylor, Deborah A. Baker, Frank C. Belz, Barry Boehm, Lori A. Clarke, David A. Fischer, Leon J. Osterweil, Richard Selby, Jack C. Wileden, Alexander L. Wolf, Michal Young)
Richard N. Taylor, Deborah A. Baker, Frank C. Belz, Barry Boehm, Lori A. Clarke, David A. Fischer, Leon J. Osterweil, Richard Selby, Jack C. Wileden, Alexander L. Wolf, Michal Young, "Next Generation Software Environment: Principles, Problems, and Research," Dep. Inform. Comput. Sci., Univ. Calif., Irvine, CA, Tech. Rep. 87-16, July 1987, also issued as Arcadia Doc. UCI-87-10, Univ. Colorado Tech. Rep. CU-CS-370- 87, Univ. Mass., Amherst, Tech. Rep. 87-63, and Incremental Systems Corp. Tech. Rep. 87-7-1 (pdf)
The past decade has seen a burgeoning of research and development in software environments. Conferences have been devoted to the topic of practical environments, journal papers produced, and commercial systems sold. Given all the activity, one might expect a great deal of consensus on issues, approaches, and techniques. This is not the case, however. Indeed, the term "environment" is still used in a variety of conflicting ways. Nevertheless substantial progress has been made and we are at least nearing consensus on many critical issues.
The purpose of this paper is to characterize environments, describe several important principles that have emerged in the last decade or so, note current open problems, and describe some approaches to these problems, with particular emphasis on the activities of one large-scale research program, the Arcadia project. Consideration is also given to two related topics: empirical evaluation and technology transition. That is, how can environments and their constituents be evaluated, and how can new developments be moved effectively into the production sector?
Added June 18th, 2008
USC-CSE-87-500 - Software Process Management: Lessons Learned from History (Barry Boehm)
Regarding history, George Santayana once said, "Those who cannot remember the past are condemned to repeat it."
I have always been dissatisfied with that statement. It is too negative. History has positive experiences too. They are the ones we would like both to remember and to repeat.
The three papers in this session are strong examples of positive early experiences in large-scale software engineering. The papers are:
H.D. Benington, "Production of Large Computer Programs," Proceedings, ONR Symposium, June 1956.
W.A. Hosier, "Pitfalls and Safeguards in Real-Time Digital Systems with Emphasis on Programming," IRE Transactions on Engineering Management, June, 1961.
W.W. Royce, "Managing the Development of Large Software Systems: Concepts and Techniques," Proceedings, WESCON, August 1970.
Given the short lifespan of the software field, they can certainly be called "historic." Indeed, since many people date the software engineering field from the NATO Garmisch conference in 1968, two of them can even be called "prehistoric." They are certainly sufficiently old that most people in the software engineering field have not been aware of them. The intent of this session is to remedy this situation by reprinting them in the Conference Proceedings, and by having the authors (or, in one case, Hosier's colleague J.P. Haverty) discuss both the lessons from their papers which are still equally valid today, and the new insights and developments which have happened in the interim.
Currently, software cost estimation models are at best accurate to within 20 percent of the actual real costs about 70 percent of the time. One of the reasons they are not any better is that the data to which they are calibrated isn't any better. Futhermore, I think the situation is going to get worse before it gets better because of the uncertain effect of such new technologies as rapid prototyping, Very High Level Languages, and Ada.
We need a consistent set of counting rules for Ada programs. Lines of Ada code are put through a "pretty printer" and suddenly you have a program that is twice as large. We need to define and collect data very carefully. One exception to all this pessimism is the ESD Software Management Metrics, which I think are going to lead to some very valuable data in the process of helping ESD manage its software projects.
Added June 18th, 2008
USC-CSE-86-501 - Understanding and Controlling Software Costs (Barry Boehm)
Understanding of software costs is important because of the overall magnitude of these costs (in 1985, roughly $70 billion per year in the U.S. and over $140 billion per year worldwide) and because of the fundamental impact software will have on our future quality of life. Section 1 of this paper discusses these issues.
Section 2, the main portion of the paper, discusses the two primary ways of understanding software costs. The "black-box" or influence-function approach provides useful experimental and observational insights on the relative software productivity and quality leverage of various management, technical, environmental, and personnel options. The "glass-box" or cost distribution approach helps identify strategies for integrated software productivity and quality improvement programs, via such structures as the value chain and the software productivity opportunity tree.
The most attractive individual strategies for improving software productivity
identified in Section 2 are:
Writing less code;
Getting the best from people;
Avoiding rework;
Developing and using integrated project support environments.
Section 2 provides overall surveys of early and recent progress along these and other lines identified by the opportunity tree.
Better understanding of software costs leads to better methods of controlling software project costs, and vice versa. Section 3 discusses these issues. It points out that some good frameworks of techniques exist for controlling software budgets, schedules, and work completed, but that a great deal of further progress is needed to provide an overall set of planning and control techniques covering software product qualities and end-user system objectives.
Added June 13th, 2008
USC-CSE-86-500 - A Value-Chain Analysis of Software Productivity Components (Barry Boehm, Phillip N. Papaccio)
This paper summarizes a recent value-chain analysis of software productivity components at TRW. It explains the various value chain components and percentages, assesses their implications for improving software productivity, and elaborates on some further data analysis performed to address one of the major value chain components: rework costs.
Added June 13th, 2008
USC-CSE-85-499 - Industrial Software Metrics: A Top-Ten List (Barry Boehm)
Barry Boehm "Industrial Software Metrics: A Top-Ten List," IEEE Software, Volume 4, Number 5, September 1987, pp. 84-85 (pdf)
I am always fascinated by Top-Ten lists. So, when Vincent Shen asked me to write this column, I thought I would present my candidate Top-Ten list of software metric relationships, in terms of their value in industrial situations.
Added June 13th, 2008
USC-CSE-84-501 - A Software Development Environment for Improving Productivity (Barry Boehm, Maria H. Penedo, E. Don Stuckle, Robert D. Williams, Arthur B. Pyster)
Barry Boehm, Maria H. Penedo, E. Don Stuckle, Robert D. Williams, Arthur B. Pyster, "A Software Development Environment for Improving Productivity," Computer, Volume 17, Number 6, June 1984, pp. 30-44 (pdf)
A major effort at improving productivity at TRW led to the creation of the software productivity project, or SPP, in 1981. The major thrust of this project is the establishment of a software development environment to support project activities; this environment is called the software productivity system, or SPS. It involves a set of strategies, induding the work environment; the evaluation and procurement of hardware equipment; the provision for immediate access to computing resources through loca1 area networks; the building of an integrated set of tools to support the software development life cycle and all project personnel: and a user support function to transfer new technology. All of these strategies are being accomplished incrementally. The current architecture is Vax-based and uses the Unix operating system, a wideband local network,
and a set of software tools.
This article describes the steps that led to the creation of the SPP, summarizes the requirements analyses on which the SPS is based, describes the components which
make up the SPS, and presents our conclusions.
Barry Boehm, "Software Engineering Economics," IEEE Transactions on Software Engineering , Volume SE-10, Number 1, January 1984, pp. 4-21 (pdf)
This paper summarizes the current state of the art and recent trends in software engineering economics. It provides an overview of economic analysis techniques and their applicability to software engineering and management. It surveys the field of software cost estimation, including the major estimation techniques available, the state of the art in algorithmic cost models, and the outstanding research issues in software cost estimation.
Added July 25th, 2008
USC-CSE-83-503 - Software Project Predictability and Control (Barry Boehm)
Barry Boehm, "Software Project Predictability and Control," AF/SA8, 1983 (pdf)
Software project predictability and control is critical to the Air- Force for two
main reasons:
1. Software projects are inherently difficult to predict and control.
2. Software is necessarily on the critical path in many Air Force system acquisitions. Thus, any software project slippages are directly translated into slippages in operational readiness for many Air Force weapon systems and C3I systems.
The second section of this chapter discusses the nature of the software predictability and control problem: what is it about software projects which makes them difficult to predict and control? The third section discusses a number of techniques for improving software predictability and control which the Study Group found being applied successfully in some parts of the Air Force, including the use of prototyping, incremental development, design-to-cost, competitive analysis and design contracts, and software development capability /capacity reviews.
However, the Study Group found that these and other proven software risk management techniques are not being used in many Air Force system acquisitions. The Study Group concluded that a significant improvement in software project predictability and control would be effected by thorough application of these techniques, and that the most effective ways to get them used would be to establish and ensure the application of two further Air Force policies:
1. A policy on software risk management;
2. A policy on software oversight management.
Section 4 of this chapter presents and discusses the proposed policy on software
risk management, presented as an additional chapter in the relevant Air Force regulation: AFR 800-14, Vol. II, "Acquisition and Support Procedures for Computer Resources in Systems." Section 5 presents the corresponding recommended policy on software oversight management.
Added June 6th, 2008
USC-CSE-83-502 - The Economics of Software Maintenance (Barry Boehm)
Barry Boehm, "The Economics of Software Maintenance," Proceedings of the Software Maintenance Workshop, Washington, D.C., 1983, pp. 9-37 (pdf)
Economic models and principles can help us:
Improve software maintenance productivity
Understand the software maintenance process
In this talk I will address two theses:
1. Economic models and principles can help us improve software maintenance productivity. I will illustrate this thesis with some insights based on the COCOMO model for estimating software maintenance costs.
2. Economic models and principles can help us understand the software maintenance process. I will illustrate this thesis by presenting a rationale showing how economic decisions made by software maintenance managers drive the software maintenance process into a dynamic equilibrium. The evolution dynamics of this equilibrium reflect and extend such current laws as the five Belady-Lehman laws of evolution dynamics.
Added June 6th, 2008
USC-CSE-83-500 - Seven Basic Principles of Software Engineering (Barry Boehm)
This paper attempts to distill the large number of individual aphorisms on good software engineering into a small set of basic principles. Seven principles have been determined which form a reasonably independent and complete set. These are: (1) manage using a phased life-cycle plan; (2) perform continuous validation; (3) maintain disciplined product control; (4) use modern programming practices; (5) maintain clear accountability for results: (6) use better and fewer people; and (7) maintain a commitment to improve the process. The overall rationale behind this set of principles is discussed, followed by a more detailed discussion of each of the principles.
USC-CSE-82-500 - Prototyping vs. Specifying: A Multi-Project Experiment (Barry Boehm, Terence E. Gray, Thomas Seewaldt)
In this experiment, seven software teams developed versions of the same small-size (2000.4000 source instruction) application software product. Four teams used the Specifying approach. Three teams used the Prototyping approach.
The main results of the experiment were:
Prototyping yielded products with roughly equivalent performance, but with about 40% less code and 45% less effort.
The prototyped products rated somewhat lower on functionality and robustness, but higher on ease of use and ease of learning.
Specifying produced more coherent designs and software that was easier to integrate.
The paper presents the experimental data supporting these and a number of additional conclusions.
Added June 6th, 2008
USC-CSE-79-500 - Software Engineering - As It Is (Barry Boehm)
Barry Boehm, "Software Engineering - As It Is," Proceedings, 4th International Conference on Software Engineering, September 1979, pp. 11-21 (pdf)
This paper presents a view of software engineering as it is in 1979. It discusses current software engineering practice with respect to lessons learned in the past few years, and concludes that the lessons are currently not heeded roughly half of the time. The paper discusses some of the factors which may account for this lag, including rapid technological change, education shortfalls, technology transfer inhibitions, resistance to disciplined methods, inappropriate role models, and a restricted view of software engineering.
The paper also updates a 1976 state of the art survey of software engineering technology, including such topics as requirements and specifications, design, programming, verification and validation, maintenance, software psychology, and software economics. It concludes that the field is making solid progress, but that it is growing more complex at a faster rate than we can put it in order.
Added June 6th, 2008
USC-CSE-76-501 - Quantitative Evaluation of Software Quality (Barry Boehm, J. R. Brown, M. Lipow)
The study reported in this paper establishes a conceptual framework and some key initial results in the analysis of the characteristics of software quality. Its main results and conclusions are:
• Explicit attention to characteristics of software quality can lead to significant savings in software life-cycle costs.
• The current software state-of-the-art imposes specific limitations on our ability to automatically and quantitatively evaluate the quality of software.
• A definitive hierarchy of well-defined, well-differentiated characteristics of software quality is developed. Its higher-level structure reflects the actual uses to which software quality evaluation would be put; its lower-level characteristics are closely correlated with actual software metric evaluations which can be performed.
• A large number of software quality-evaluation metrics have been defined, classified, and evaluated with respect to their potential benefits, quantifiability, and ease of automation.
• Particular software life-cycle activities have been identified which have significant leverage on software quality.
Most importantly, we believe that the study reported in this paper provides for the first time a clear, well-defined framework for assessing the often slippery issues associated with software quality, via the consistent and mutually supportive sets of definitions, distinctions, guidelines, and experiences cited. This framework is certainly not complete, but it has been brought to a point sufficient to serve as a viable basis for future refinements and extensions.
This paper provides a definition of the term "software engineering" and a survey of the current state of the art and likely future trends in the field. The survey covers the technology available in the various phases of the software life cycle-requirements engineering, design, coding, test, and maintenance-and in the overall area of software management and integrated technologymanagement approaches. It is oriented primarily toward discussing the domain of applicability of techniques (where and when they work), rather than how they work in detail. To cover the latter, an extensive set of 104 references is provided.
Added June 6th, 2008
USC-CSE-75-501 - Software Design and Structuring (Barry Boehm)
Barry Boehm, "Software Design and Structuring," Practical Strategies for Developing Large Software Systems, edited by Ellis Horowitz, 1975, pp. 103-128 (pdf)
In 1974, the major leverage point in the software process is at the software design and structuring stage. This stage begins with a statement of software requirements. Properly done, the software design and structuring process can identify the weak spots and mismatches in the requirements statement which are the main sources of unresponsiveness of delivered software. Once these weak spots slip by the design phasel they will generally stay until during or after delivery, where only costly retrofits can make the software responsive to operational needs.
The software design and structuring phase ends with a detailed specification of the code that is to be produced, a plan for testing the code, and a draft set of users' manuals describing how the product is going to be used. Software costs and problems result from allowing coding to begin on a piece of software before its design aspects have been thoroughly worked out, verified, and validated.
This paper provides a classification of software design and structuring techniques into a few main categories which can currently be considered as software design alternatives. For each alternative, it presents a short description and a balance sheet indicating the advantages and difficulties in using the technique.
In an overall comparison of the alternative techniques, none of them provides positive assurance of satisfying all the criteria, but each criterion is satisfied by at least one of the techniques. This would lead one to believe that an appropriate synthesis of the techniques might prove successful.
The following major design and structuring alternatives will be described and evaluated: Bottom-up, Top-down stub, Top-down/Problem Statement, Structured Programming, and Model-driven Design.
USC-CSE-75-500 - Some Experience with Automated Aids to the Design of Large-Scale Reliable Software (Barry Boehm, Robert K. McClean, D. B. Ufrig)
Barry Boehm, Robert K. McClean, D. B. Ufrig, "Some Experience with Automated Aids to the Design of Large-Scale Reliable Software," IEEE Transaction on Software Engineering, Volume 1, Number 1, March 1975, pp. 125-133 (pdf)
Recently, the Air Force Systems Command completed a study, "Information Processing/Data Automation Implications of Air Force Command and Control Requirements in the 1980s," or CCIP-85 for short. The study projected future Air Force command and control information processing requirements and likely future information processing capabilities into the 1980s, and developed an Air Force R&D plan to correct the mismatches found between likely capabilities and needs.
Although many of the CCIP-85 conclusions are specific to the Air Force, there are a number of points which hold at least as well elsewhere. This article summarizes those transferable facts and conclusions.
Basically, the study showed that for almost all applications, software (as opposed to computer hardware, displays, architecture, etc.) was "the tall pole in the tent"-the major source of difficult future problems and operational performance penalties. However, we found it difficult to convince people outside the software business of this. This was primarily because of the scarcity of solid quantitative data todemonstrate the impact of software on operational performance or to provide perspective on R&D priorities.
The study did find and develop some data which helped illuminate the problems and convince people that the problems were significant. Surprisingly, though, we found that these data are almost unknown even to software practitioners. The main purpose of this article is to make these scanty but important data and their implications better known, and to convince people to collect more of it.
Added June 6th, 2008
USC-CSE-73-500 - Software and Its Impact: A Quantitative Assessment (Barry Boehm)
Barry Boehm, "Software and Its Impact: A Quantitative Assessment," Datamition, May 1973, pp. 48-59 (pdf)
Recently, the Air Force Systems Command completed a study, "Information Processing/Data Automation Implications of Air Force Command and Control Requirements in the 1980s," or CCIP-85 for short. The study projected future Air Force command and control information processing requirements and likely future information processing capabilities into the 1980s, and developed an Air Force R&D plan to correct the mismatches found between likely capabilities and needs.
Although many of the CCIP-85 conclusions are specific to the Air Force, there are a number of points which hold at least as well elsewhere. This article summarizes those transferable facts and conclusions.
Basically, the study showed that for almost all applications, software (as opposed to computer hardware, displays, architecture, etc.) was "the tall pole in the tent"-the major source of difficult future problems and operational performance penalties. However, we found it difficult to convince people outside the software business of this. This was primarily because of the scarcity of solid quantitative data to demonstrate the impact of software on operational performance or to provide perspective on R&D priorities.
The study did find and develop some data which helped illuminate the problems and convince people that the problems were significant. Surprisingly, though, we found that these data are almost unknown even to software practitioners. The main purpose of this article is to make these scanty but important data and their implications better known, and to convince people to collect more of it.
Added June 6th, 2008
Gregory Bolcer
USC-CSE-94-498 - User Interface Design Assistance for Large-Scale Software Development (Gregory Bolcer)
Gregory Bolcer, "User Interface Design Assistance for Large-Scale Software Development," Automated Software Engineering, Springer Netherlands, Volume 2, Number 3, September, 1995, pp. 203-217 (pdf)
The User Interface Design Assistant (UIDA) addresses the specific design problems of style and integration consistency throughout the user interface development process and aids in the automated feedback and evaluation of a system's graphical user interface according to knowledge-based rules and project specific design examples. The UIDA system is able to quickly identify inconsistent style guide interpretations and UI design decisions resulting from distributed development of multiple UI sub-systems. This case arises when each sub-system conforms to the general style guide rules, but when integrated together, may appear inconsistent.
Prasanta Bose
USC-CSE-95-509 - The WinWin Spiral Software Process Model (Barry Boehm, Prasanta Bose)
Barry Boehm, Prasanta Bose, "The WinWin Spiral Software Process Model," Proceedings, 3rd ICSP, 1994 (pdf)
A primary difficulty in applying the Spiral model has been the lack of explicit process guidance in determining the prospective system's objectives, constraints, and alternatives that get elaborated in each cycle. This paper presents an extension of the spiral model, called the WinWin process model, which uses the Theory W (win-win) approach to converge on a system's next level objectives, constraints, and alternatives. The WinWin Spiral model explicitly addresses the need for concurrent analysis, risk resolution, definition, and elaboration of both the software product and software process in a collaborative manner. The paper discusses an application of the model, identifies the need for support systems to facilitate cost-effective realization of the model, and describes bootstrap experiments that lead to identifying key capabilities of support systems for the model. The key elements of the evolved WinWin support system developed to meet the needs are also discussed.
USC-CSE-95-505 - Conceptual Design Model based Requirements Analysis in the WinWin Framework for Concurrent Requirements Engineering (Prasanta Bose)
Prasanta Bose, "Conceptual Design Model based Requirements Analysis in the WinWin Framework for Concurrent Requirements Engineering," International Workshop on Software Specification and Design, IWSSD, 1995 (pdf)
The WinWin framework provides a domain independent framework for the stakeholders to collaborate and negotiate in the requirements engineering phase of the software lifecycle. Requirements engineering in the framework leads to defining a win-win requirements model expressed using a set of conceptual elements that record stakeholderUs objectives, constraints, concerns and negotiated agreements.
A major problem confronted in the current WinWin framework is win-win requirements model analysis that lead to mapping the win-win requirements model which is primarily problem oriented to a solution-oriented requirements specification model that aids in win condition analysis and consequently negotiation.
This paper presents a constructive and goal-directed modeling approach to aid in win-win requirements model analysis. The approach involves concurrently elaborating a high-level conceptual design model along with the win-win model creation. The design model representation makes explicit partially specified constraints that form the conceptual architectural basis of the win-win requirements model and aids in win-win requirements model analysis.
In this paper we present the key ideas of our approach: a) defining a domain-independent ontology for conceptual modeling of high-level design and its relationship with the WinWin model b) win-win artifact based representation of analysis goals and an abstract domain independent theory that encapsulate the conditions for satisfying the goals, and c) defining capabilities of an extended WinWin support system that to aid in analysis.
USC-CSE-95-504 - A Model for Decision Maintenance in the WinWin Collaboration Framework (Prasanta Bose)
Cost-effective engineering and evolution of complex software must involve the different stakeholders concurrently and collaboratively. The hard problem is providing computer support for such collaborative activities. The WinWin approach being developed and experimented at the USC Center for Software Engineering provides a domain independent solution for the stakeholders to cooperate in the requirements engineering phase of the software lifecycle.
The key ideas in the WinWin approach and its support are: i) defining a win-win process for obtaining requirements through collaboration and negotiation, ii) defining a decision rationale model using a minimal set of conceptual elements, such as win conditions, issues, options and agreements, that serves as an agreed upon ontology for collaboration and negotiation defined by the winwin process, and, iii) defining a support framework, based on manipulation of explicit representation of the decision rationale and reasoning about it.
A major problem confronted in the WinWin framework is aiding decision coordination - coordinating the decision making activities of the stakeholders. A key element in supporting decision coordination is decision maintenance. As decisions undergo evolution, the effects of such changes on existing decision elements must be determined and the decision structure appropriately revised.
This paper presents an approach to addressing the problem of supporting decision maintenance. The key ideas involve a) defining an extended ontology for decision rationale, that models the WinWin decision space and their states, b) formally describing a theory based on that ontology that specify conditions for states to hold, and c) defining an agent that utilizes the theory to determine revisions and coordinate with other agents to propagate revisions in a distributed support framework.
USC-CSE-94-505 - Some Critical Success Factors for Knowledge Based Software Engineering Applications (Barry Boehm, Prasanta Bose, Greg Toth)
Barry Boehm, Prasanta Bose, Greg Toth, "Some Critical Success Factors for Knowledge Based Software Engineering Applications," Proceedings of the International Workshop on Software Engineering Education, Sorrento, Italy, May, 1994 (pdf)
In the Spring of 1993, the authors participated in a USC seminar course in Knowledge Based Software Engineering (KBSE) which involved the development of ten prototype KBSE applications. Evaluations of these prototype applications indicated a considerable range of relative utility to practicing software engineers. For potential discussion at the SE/ AI workshop, we offer below an analysis of some critical success factors (CSF's) distinguishing the prototypes with more and less utility.
The authors' roles in this situation extended the AI user/ provider model to cover two additional bridge roles (technology advocates and technology receptors) determined by the Software Engineering Institute [Fowler-Rifkin, 1990] to be significant facilitators in software technology transition.
Prasanta Bose, whose primary field has been AI and who served as the course's associate instructor, functioned as a Technology Advocate in advancing AI capabilities for application to software engineering (SE) problems. Barry Boehm, whose primary field has been SE and who served as the course's instructor, functioned as a Technology Receptor interested in finding new KB approaches to SE problems by knowledge mining and knowledge engineering of SE domain experts. Greg Toth represented both ends of the technology transition chain: as a course student producing a prototype KBSE [Toth,1993]; and as a Northrop software manager interested in new tools for Northrop software engineering applications.
Added June 25th, 2008
USC-CSE-94-504 - Feature-Based Modeling of Software Component Interactions (Prasanta Bose)
Prasanta Bose, "Feature-Based Modeling of Software Component Interactions" (pdf)
Complex software-based system design poses significant tractability problems that can be addressed by using higher level abstractions of the design such as architecture level abstractions. The architecture-level design distinguishes coarse-grain components and interactions between them. This paper develops approximate modeling of the interactions between the components in terms of a set of features in order to facilitate limited types of consistency checking of the designs at the conceptualizing stage.
USC-CSE-94-503 - Software Requirements Negotiation and Renegotiation Aids: A Theory-W Based Spiral Approach (Barry Boehm, Ming June Lee, Prasanta Bose, Ellis Horowitz)
A major problem in requirements engineering is obtaining requirements that address the concerns of multiple stakeholders. An approach to such a problem is the Theory-W based Spiral Model. One key element of this model is stakeholder collaboration and negotiation to obtain win-win requirements. This paper focuses on the problem of developing a support system for such a model. In particular, it identifies needs and capabilities required to address the problem of negotiation and renegotiation that arises when the model is applied to incremental
