Composable Process Elements for Developing COTS-Based Applications
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.
Document characteristics: Proceedings, ISESE 2003, September/October 2003
Added: June 24, 2004
Reasoning About the Value of Dependability: The iDave Model
Barry Boehm, LiGuo Huang, Apurva Jain
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.
Document characteristics: EDSER-5 Proceedings, May 2003.
Added: June 24, 2004
Agility Through Discipline: A Debate
Barry Boehm, and Kent Beck
view the world in “both-and” terms instead of “either-or” terms. Why this disconnect?
Document characteristics: Computer, June 2003, pp. 44-46.
Added: June 24, 2004
People Factors in Software Management: Lessons From Comparing Agile and Plan-Driven Methods
Barry Boehm, and Richard Turner
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.
Calculating Architectural Reliability via Modeling and Analysis (Qualification Exam Report)
Modeling and estimating software reliability during testing is useful in quantifying the quality and dependability of the developed software systems. However, such measurements applied so late in the development process leave little to be done to improve the quality of the software system in a cost-effective way. Reliability, an important dependability attribute, is defined as the probability that the system performs its intended functionality under specified design limits. We argue that reliability models must be built to estimate the system reliability throughout the development process, and specifically when exact context and execution profile of the system may be unknown, or when the implementation artifacts are not yet available. In the context of software architectures, various techniques for modeling software systems and specifying their functional properties have been developed. These techniques enable extensive analysis of the specification, but typically lack quantification. Additionally, their relation to dependability attributes of the modelled software system is unknown.
In this proposal, we present a software architecture-based approach to estimating system reliability. The approach is applicable to early stages of development when the implementation artifacts are not yet available, and exact execution profile is unknown. The uncertainty of the execution profile is modeled using stochastic processes with unknown parameters. The approach is compositional in nature: the overall reliability of the system is estimated as a function of the reliability of its constituent components and their (complex) interactions. In turn, the reliability of individual components is estimated using standard modeling and specification mechanisms of software architectures. Additionally, sensitivity analyses enabled by our reliability model prescribe defect mitigation strategies in a cost-effective manner.
Improving Availability in Large, Distributed, Component-Based Systems via Redeployment
Marija Mikic-Rakic, Sam Malek, Nenad Medvidovic
In distributed and mobile environments, the connections among the hosts on which a software system is running are often unstable. As a result of connectivity losses, the overall availability of the system decreases. The distribution of software components onto hardware nodes (i.e., the system’s deployment architecture) may be ill-suited for the given target hardware environment and may need to be altered to improve the software system’s availability. The critical difficulty in achieving this task lies in the fact that determining a software system’s deployment that will maximize its availability is an exponentially complex problem. In this paper, we present a fast approximative solution for this problem, and assess its performance.
Added: December 15, 2003
Alfa: A Framework for Composing Software Architectures from Architectural Primitives
Nikunj R. Mehta and Nenad Medvidovic
Architectural styles represent composition patterns and constraints at the software architectural level and are targeted at families of systems with shared characteristics. They enable architectural reuse and hence can bring economy to architecture-based software development. Existing research on architectural styles provides little guidance for the systematic design and construction of architectural style elements. This paper proposes a framework, Alfa, for systematically and constructively composing “architectural primitives” to obtain elements of architectural styles. This is based on our observation that architectural styles and, indeed, software architectures share many underlying concepts that lead to architectural primitives. We have identified eight forms and nine functions as architectural primitives that reflect the syntactic and semantic characteristics of software architectures and are expressive enough to compose elements of architectural styles used in modern, distributed systems. Such an approach enables systematic construction of style-based architectures. In that direction, this paper evaluates the suitability of Alfa as an assembly language for software architectures and its suitability for composing architectural styles for network-based systems.
Added: November 25, 2003
The Schedule as Independent Variable (SAIV) Process for Acquisition of Software-Intensive Systems
Barry Boehm, Winsor
Brown, LiGuo Huang, and
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 19, 2003
Concise Composition of Architectural Styles From Architectural Primitives
Nikunj R. Mehta, Nenad Medvidovic
Architectural styles represent composition patterns and constraints at the software architectural level and are targeted at families of systems with shared characteristics. They enable architectural reuse and hence can bring economy to the design of software architecture. Existing approaches support systematic description of style-based software architectures. Our approach, Alfa, focuses on the construction, instead of description, of style-based software architectures using architectural primitives. This is based on our observation that architectural styles and, indeed, software architectures share many underlying concepts that lead to architectural primitives. Previously, Alfa’s primitives were shown to be sufficient for modeling architectural styles. In this paper, we present the composition of a diverse set of styles for network-based systems using xAlfa, a systematic notation for composing styles from Alfa’s primitives. We then show that two reuse mechanisms in xAlfa, inheritance and composition, enable concise style compositions and unambiguously bring out similarities among architectural styles.
Updated: October 30, 2003
Effective Modeling of Software Architectural Assemblies Using Constraint Automata
Nikunj R. Mehta, Marjan Sirjani, Farhad Arbab
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.
Updated: September 25, 2003
Using Multiple Views to Model and Analyze Software Architecture: An Experience Report
Roshanak Roshandel, Bradley Schmerl, Nenad Medvidovic, David Garlan, Dehua Zhang
modeling and analysis is a critical phase in developing large and complex
software systems. The usefulness of multiple views has likewise long been
recognized. In this experience report, we explain how we used two ADLs to model a system initially described in UML. The
system SCRover) is designed and built in close
collaboration with NASA’s Jet Propulsion Laboratory, using their
Updated: September 18, 2003
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
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.
Updated: September 18, 2003
Software Architectural Support for Disconnected Operation in Highly Distributed Environments
Marija Mikic-Rakic, and Nenad Medvidovic
In distributed and mobile environments, the connections among the hosts on which a software system is running are often unstable. As a result of connectivity losses, the overall availability of the system decreases. The distribution of software components onto hardware nodes (i.e., deployment architecture) may be ill-suited for the given target hardware environment and may need to be altered to improve the software system's availability. The critical difficulty in achieving this task lies in the fact that determining a software system's deployment that will maximize its availability is an exponentially complex problem. In this paper, we present an automated, flexible, software architecture-based solution for disconnected operation that increases the availability of the system during disconnection. We provide a fast approximative solution for the exponentially complex redeployment problem, and assess its performance.
Document characteristics: Submitted to ICDCS 2004.
Updated: September 17, 2003
Value-Based Software Engineering: A Case Study
Barry Boehm and Li Guo Huang
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.
Document characteristics: Published at IEEE Computer, March 2003, Vol. 36, No. 3.
Updated: April 26, 2003
Relating Software Component Models
Roshanak Roshandel, and Nenad Medvidovic
A software component is typically modeled at one or more of four levels: interface, static behavior, dynamic behavior, and interaction protocol. Each of these levels helps to ensure different aspects of component compatibility and interoperability. Existing approaches to component modeling have either focused on only one of the levels (e.g., interfaces in various IDLs) or on well-understood combinations of two of the levels (e.g., interfaces and their associated pre- and post-conditions in static behavioral modeling approaches). This paper argues that, in order to accrue the true benefits of component-based software development, one may need to model components at all four levels. Before that can be possible, one needs to understand the relationships among the different models. We detail one such pair-wise relationship—between static and dynamic component models—and draw parallels between it and the remaining models.
added: March 26, 2003
Composing Architectural Styles From Architectural Primitives
Nikunj Mehta, and Nenad Medvidovic
Architectural styles are named collections of constraints on configurations of architectural elements, and are believed to bring economies of scale in applying software architecture techniques to software development. Most research on architectural styles focuses on analyzing and observing the properties of such styles from their descriptions. However, comparatively little is known about the systematic design and construction of software architectures using architectural styles. Existing classifications bring out differences between architectural styles, but none provides a clear understanding of the similarities among a large number of styles. The basis of our research is the observation that architectural styles share many underlying concepts. These shared concepts lead to “architectural primitives” that can be systematically and constructively composed to obtain elements of architectural styles. We have identified eight forms and nine functions as architectural primitives that, in our understanding, reflect the syntactic and semantic characteristics of a large number of styles. While proving such a hypothesis is difficult in the general case, we demonstrate it within the domain of network-based styles. Partial formal models of style elements composed from these architectural primitives are also constructed and shown to be analyzable.
Document characteristics: Submitted to ESEC/FSE 2003
added: March 16, 2003
Estimating the Cost of Security for COTS Software
Donald J. Reifer, Barry W. Boehm, and Murali Gangadharan
paper describes enhancements being made to the
Document characteristics: In Proceedings of 2nd International Conference on COTS-Based Software Systems, February 2003
Not All CBS Are Created Equally: COTS-Intensive Project Types
Barry W. Boehm,
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.
JavaBeans and Software Architecture
Nenad Medvidovic, and Nikunj Mehta
Java has emerged as a popular
programming language and platform for Web applications. JavaBeans? defines the software component model in the Java
programming language that is used for creating reusable, coarse-grained
components. Beans are used in numerous complementary technologies including
Copyright 1995, 1996, 1997, 1998, 1999 The University of Southern California
The written material, text, graphics, and software available on this page and all related pages may be copied, used, and distributed freely as long as the University of Southern California as the source of the material, text, graphics or software is always clearly indicated and such acknowledgement always accompanies any reuse or redistribution of the material, text, graphics or software; also permission to use the material, text, graphics or software on these pages does not include the right to repackage the material, text, graphics or software in any form or manner and then claim exclusive proprietary ownership of it as part of a commercial offering of services or as part of a commercially offered product.