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 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," accepted for Proceedings, ICRE99, June 1999 (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.
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?" IEEE Computer, January 1999 (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," submitted to the Workshop on Continuing Collaborations for Successful COTS Development, ICSE 2000, Limerick, Ireland, June 4-5, 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" (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-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 - Composing Heterogeneous Software Architectures
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 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
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-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 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
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 conunercial 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 tbnstituents 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
Yimin Bao
Yimin Bao's 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)
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
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 conunercial 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 tbnstituents 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-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%.
Added February 22nd, 2008
USC-CSSE-2007-735 - A Framework for the Assessment and Selection of Software Components 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 of Software Components and Connectors in COTS-Based Architectures" Sixth Working IEEE/IFIP Conference on Software Architecture, Mumbai, India, January 2007 (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%.
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 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-2008-815 - Experimental Evaluation of Wiki Technology and the S
