University of Southern California
    
Home   Contact Us    
Center for Systems and Software Engineering

About us
News
History
People
Events
Upcoming
Highlights
Past
Publication
Tech. Report
TR by Author
Research
Projects
Tools
Courses
Education
Degrees
Admissions
Affiliates
List of Affiliates
Private Area
Other Resources


Technical Reports

USC-CSE-2002-520

Barry Boehm, "Early Experiences in Software Economics," Software Pioneers: Contributions to Software Engineering, Springer-Verlag, 2002, pp. 632-640 (pdf)

It took me a while to appreciate software economics.

My first exposure to software economics came on my first day in the software business, in June 1955 at General Dynamics in San Diego.  My supervisor took me on a walking tour through the computer, an ERA 1103 which occupied most of a large room.  His most memorable comment was,

"Now listen.  We're paying this computer six hundred dollars an hour, and we're paying you two dollars an hour, and I want you to act accordingly."

Added May 5th, 2001


USC-CSE-2002-519

Andre van der Hoek, Ebru Dincel, Nenad Medvidovic, "Using Service Utilization Metrics to Assess and Improve Product Line Architectures," Proceedings of the 6th Ground System Architectures Workshop (GSAW 2002), El Segundo, CA, March 2002 (pdf)

Metrics have long been used in software engineering to measure, evaluate, and improve software products and processes. Many metrics have been developed and their subsequent use in different settings has led to varying levels of success. Software architecture is a discipline in which few metrics have been applied, a surprising fact given the important role that software architecture plays in software development. Software product line architectures represent one area of software architecture in which metrics can be of especially great use. The critical importance of the structure defined by a product line architecture requires that its properties be meaningfully assessed and that informed architectural decisions be made to guide its evolution. In this paper, we present several novel metrics that we have designed to address this issue. These metrics are based on the concept of service utilization and are designed to take into account the context in which individual architectural elements are placed. We show the utility of the metrics by applying them in a case study involving a digital library product line architecture. In doing so, we demonstrate how the metrics illustrate deficiencies that, when addressed, improve the overall structural quality of the product line architecture.

Added March 14th, 2001


USC-CSE-2002-518

Nenad Medvidovic, "On the Role of Middleware in Architecture-Based Software Development," ACM International Conference Proceeding Series, Proceedings of the 14th international conference on Software engineering and knowledge engineering, SESSION: Component-based software engineering, Ischia, Italy, Volume 27, 2002, pp. 299-306 (pdf)

Software architectures promote development focused on modular functional building blocks (components), their interconnections (configurations), and their interactions (connectors). Since architecture-level components often contain complex functionality, it is reasonable to expect that their interactions will be complex as well. Middleware technologies such as CORBA, COM, and RMI, provide a set of predefined services for enabling component composition and interaction. However, the potential role of such services in the imple-mentations of software architectures is not well understood. Furthermore, components adhering to one mid-dleware standard cannot readily interact with those adhering to another. In order to understand the role and tradeoffs among middleware technologies in implementing architectures and enable component interoperability across middleware platforms, we have investigated a set of techniques and conducted case studies involving a particular architectural style, C2, and its implementation infrastructure. In particular, by encapsulating middleware functionality within C2’s explicit software connectors, we have been able to couple C2’s existing benefits such as component interchangeability, substrate independence, and structural guidance with new capabilities of multi-lingual, multi-process, and distributed application development in a manner that is transparent to architects. Furthermore, we have demonstrated the utility of our connector-based approach in enabling components implemented on top of different middleware platforms to interoperate. Though several details of our approach derive from the characteristics of the C2 style, we believe that a number of lessons learned are more generally applicable. We argue that these lessons can help form a broader research agenda for coupling the modeling power of software architectures with the implementation support provided by middleware.

Added November 13th, 2000


USC-CSE-2002-517

Forrest Shull, Vic Basili, Barry Boehm, A. Winsor Brown, Patricia Costa, Mikael Lindvall, Dan Port, Ioana Rus, Roseanne Tesoriero, Marvin Zelkowitz, "What We Have Learned About Fighting Defects," Proceedings of the Eighth IEEE Symposium on Software Metrics, 2002, pp. 249-258 (pdf)

The Center for Empirically Based Software Engineering helps improve software development by providing guidelines for selecting development techniques, recommending areas for further research, and supporting software engineering education. A central activity toward achieving this goal has been the running of “eWorkshops” that capture expert knowledge with a minimum of overhead effort to formulate heuristics on a particular topic. The resulting heuristics are a useful summary of the current state of knowledge in an area based on expert opinion.

This paper discusses the results to date of a series of eWorkshops on software defect reduction. The original discussion items are presented along with an encapsulated summary of the expert discussion. The reformulated heuristics can be useful both to researchers (for pointing out gaps in the current state of the knowledge requiring further investigation) and to practitioners (for benchmarking or setting expectations about development practices). The heuristics will be further refined during a physical expert workshop at the 2002 Metrics Symposium.

Added February 1st, 2011


USC-CSE-2002-516

Chris Abts, "COTS-Based Systems (CBS) Functional Density—A Heuristic for Better CBS Design," Lecture Notes in Computer Science, Springer Berlin / Heidelberg, COTS-Based Software Systems, Volume 2255/2002, pp. 1-9 (pdf)

The conventional rationale for using COTS (commercial off-the-shelf) components is that the more a software system is built from COTS products, the lower the cost of initial development. Less understood is that during the long term sustainment phase—from deployment through retirement—the cost of maintenance of a COTS-based system generally increases as the number of COTS products used increases. There exists then a tension between the imperative to maximize the use of COTS components to ease CBS development yet minimize the use of COTS components to ease CBS maintenance. A heuristic called the “CBS Functional Density Rule” is proposed to reconcile these two conflicting views. A corresponding metric for characterizing the “efficiency” of a given CBS design relative to another called the “COTS Functional Density” is then suggested. The paper concludes with suggestions for additional research to further validate the empirical foundations of the proposed heuristic and associated metric.

Added July 18th, 2004


USC-CSE-2002-515

Tom DeMarco, Barry Boehm, "The Agile Methods Fray," Computer, June 2002, pp. 90-92 (pdf)

In Computer’s January 2002 issue, Barry Boehm presented a fresh look at a set of software development methods often referred to as agile or extreme programming (“Get Ready for Agile Methods, with Care,” Jan. 2002, pp. 64-69). This favorable assessment by one of the software establishment’s leading lights prompted the latest of several e-mail dialogues between Boehm and software luminary Tom DeMarco, who strongly advocates that the software establishment begin moving toward agile methods.

Added June 24th, 2004


USC-CSE-2002-514

Barry Boehm, Bert Steece, Jongmoon Baik, "Disaggregating and Calibrating the CASE Tool Variable in COCOMO II," IEEE Transactions on Software Engineering, Volume 28, Issue 11, November 2002, pp. 1009-1022 (pdf)

Software systems of today are frequently composed from prefabricated, heterogeneous components that provide complex functionality and engage in complex interactions. Software architecture research has revealed the importance of component interactions on our ability to perform software composition. Various development organizations have found interaction mismatches to be both difficult and a core issue behind failed software integration efforts. This paper is aimed at improving the understanding of component interactions, embodied in the notion of software connectors, in order to prevent such failures. Our previous work has resulted in a four-level classification framework for studying the characteristics of connectors. This paper presents a comprehensive taxonomy of software connectors based on the previously published connector classification framework. This taxonomy is used to explain various existing software connectors and study compatibility of connector characteristics, intended to prevent component interaction mismatches.

Added June 24th, 2004


USC-CSE-2002-513

Barry Boehm, "Get Ready for Agile Methods, with Care," Computer, January 2002, pp. 64-69 (pdf)

Software systems of today are frequently composed from prefabricated, heterogeneous components that provide complex functionality and engage in complex interactions. Software architecture research has revealed the importance of component interactions on our ability to perform software composition. Various development organizations have found interaction mismatches to be both difficult and a core issue behind failed software integration efforts. This paper is aimed at improving the understanding of component interactions, embodied in the notion of software connectors, in order to prevent such failures. Our previous work has resulted in a four-level classification framework for studying the characteristics of connectors. This paper presents a comprehensive taxonomy of software connectors based on the previously published connector classification framework. This taxonomy is used to explain various existing software connectors and study compatibility of connector characteristics, intended to prevent component interaction mismatches.

Added June 24th, 2004


USC-CSE-2002-512

Barry Boehm, Dan Port, LiGuo Huang, Winsor Brown, "Using The Spiral Model and MBASE to Generate New Acquisition Process Models: SAIV, CAIV, and SCQAIV," CrossTalk, January 2002, pp. 20-25 (pdf)

In this article, we show how you can use the MBASE process framework to generate a family of acquisition process models for delivering user-satisfactory systems under schedule, cost, and quality constraints. We present the six major steps of the Schedule/Cost/Schedule-Cost-Quality as Independent Variable (SAIV/CAIV/SCQAIV) process using SAIV and a representative Department of Defense (DoD) Command, Control, and Communications Interoperability application as context. We then summarize our experience in using SAIV on 26 University of Southern California electronic services projects, followed by discussions of SAIV/CAIV/SCQAIV application in the commercial and defense sectors, of model application within the DoD acquisition framework, and of the resulting conclusions.

Added June 24th, 2004


USC-CSE-2002-511

Nikunj R. Mehta, Nenad Medvidovic, "Understanding Software Connector Compatibilities Using A Connector Taxonomy," submitted to SoDA 2002 (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 October 29th, 2002


USC-CSE-2002-509

Nikunj R. Mehta, Nenad Medvidovic, "Distilling Software Architecture Primitives from Architectural Styles," submitted to ICSE 2003 (pdf)

Architectural styles codify commonly used idioms in system structures, organizations, and interactions. Existing classifications of architectural styles provide empirical guidelines for style selection, but fail to systematically characterize styles or reveal their foundations. Moreover, the mapping between architectural styles and their implementations is generally poorly understood. This paper introduces an approach towards a systematic understanding of architectural styles based on a small set of recurring architectural primitives. Also proposed is an extensible composition framework for architectural styles based on these primitives, which is, in turn, used as the basis of style implementation. This framework, called Alfa, has been applied successfully to four different architectural styles to date. Lightweight compositional models of the styles have been created using the Alloy formal modeling notation, whereas implementation infrastructures for these styles have been developed in Java. While it would be premature to claim that Alfa is sufficiently expressive to represent any arbitrary architectural style, our experience to date suggests that we have converged on a set of primitives that effectively captures the characteristics of a large number of styles. As such, we feel that Alfa already presents a unique contribution and is worthy of careful further study.

Added September 16th, 2002


USC-CSE-2002-508

Marija Mikic-Rakic, Nenad Medvidovic, "Software Architecture-Based Development Support for Ubiquitous Systems" (pdf)

Over the past several decades software researchers and practitioners have proposed various approaches, techniques, and tools for developing large-scale software systems. A new set of challenges has arisen with the emergence of inexpensive, small, heterogeneous, resource-constrained, possibly embedded, highly-distributed, and highly-mobile computing platforms that are permeating virtually every facet of life (i.e., ubiquitous systems). This paper presents an approach to software development for ubiquitous systems whose intent is to address these challenges. Our approach to Prism directly leverages the principles and solutions from the emerging body of work on software architectures. We refer to software development in this setting as programming in the small and many (Prism), in order to distinguish it from the commonly adopted software engineering paradigm of programming in the large (PitL). The centerpiece of our approach is a software architectural style and its middleware that support the key aspects of Prism applications: self-awareness, distribution, heterogeneity, dynamism, mobility, and graceful degradation. Our approach has been successfully applied on a number of ubiquitous applications. While several issues pertaining to Prism remain areas of future work, our experience to date has been very positive.

Added September 8th, 2002


USC-CSE-2002-507

Nenad Medvidovic, Andre van der Hoek, "An Example Product Line Architecture: The Library System" (pdf)

The Library System case study was performed to experiment with alternative approaches for realizing diverse concepts within the KobrA [Atkinson, 2002 #1195] method developed at Fraunhofer Institute for Experimental Software Engineering (IESE) [IESE, #1197] . The case study is publicly available on the institute’s web site [Bayer, #1196]. The scope of the domain of library system is characterized by the common and variable aspects of different systems in the library systems product line. For this case study, the scope is based on three types of library systems: a city library, a university library and a research library. The IESE research library is a specialized, scientific library for the researchers, students, and employees working at the IESE. Information gathering, documentation, training, and consulting tasks are a few of the responsibilities of this library. Similarly, the university library is a scientific library. Its purpose is to provide university members comprehensively with scientific literature. Finally, the city library is a public library. Its purpose is to provide all citizens of a city and the surrounding areas with literature and media for personal education and training. There is also an additional artificial fourth member, basic library system, that provides only the basic functionalities of a library.

Added September 6th, 2002


USC-CSE-2002-506

Nenad Medvidovic, Andre van der Hoek, "An Example Product Line Architecture: Troops Deployment System" (pdf)

Troop Deployment System (TDS) is an application for distributed deployment of personnel, intended to deal with situations such as natural disasters, search-and rescue efforts, and military crises. One specific instance of this application depicted in Figure 1 addresses military Troops Deployment and battle Simulations. A computer at Headquarters gathers information from the field and display the current battlefield status: the locations of friendly and enemy troops, as well as obstacles such as mine fields. The Headquarters computer is networked via secure links to a set of PDAs used by officers in the field. The Commanders are capable of controlling their own quadrant of the battlefield. The General can see a summarized view of the entire battlefield (shown) or detailed views of each quadrant. The General can issue direct troop deployment orders to individual Commanders or request transfers of troops among the Commanders. General can also request for deployment strategy suggestions from Headquarters. Finally, the General can issue a “fight” command, resulting in a battle simulation that incrementally determines the likely winner. The example configuration in Figure 1 shows four Commanders and no General. All four Commanders have the same set of components. For the sake of simplicity, only the Commander1’s architecture is shown. Another group of applications involve the civilians where instead of military civilians are used for search and rescue efforts.

Added September 5th, 2002


USC-CSE-2002-505

Nenad Medvidovic, Andre van der Hoek, "An Example Product Line Architecture: Digital Library Projects" (pdf)

Software application families and their accompanying architectures (also referred to as product line architectures or PLAs) are a promising area in which the potential of software component reuse can be fully realized. Evolving such application families necessitates making informed architectural decisions. Among industry and research communities, it is recognized that software metrics can provide guidance during the making of such decisions. In an earlier paper [1], we introduced metrics that are specifically geared to assess product line architectures and help in maintaining their quality.

Added September 5th, 2002


USC-CSE-2002-504

Nikunj R. Mehta, "Distilling Software Architectural Primitives from Architectural Styles," Qualification Exam Report (pdf)

Software architecture-based approaches provide high-level abstractions to deal with complexity and richness of modern software systems. Many software systems have been found to share organizational and interaction characteristics. Architectural styles have been proposed to codify commonly used idioms of component structures, organizations and interactions. Existing classifications of architectural styles provide empirical support for style selection, but fail to systematically characterize them and do not reveal the basis underlying them. Moreover, the mapping between software architecture and design is poorly understood. My doctoral research proposes to create an understanding of, and as a result a composition framework for architectural styles using a small set of architectural primitives that are reused across styles to produce effective style implementation infrastructures.

Added August 21st, 2002


USC-CSE-2002-503

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

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-2002-501

Marija Mikic-Rakic, Nenad Medvidovic, Vladimir Jakobac, "Middleware for Software Architecture-Based Development in Distributed, Mobile, and Resource-Constrained Environments" (pdf)

Over the past several decades software researchers and practitioners have proposed various approaches, techniques, and tools for developing large-scale software systems. The results of these efforts have been characterized as programming-in-the-large (PitL). A new set of challenges has arisen with the emergence of inexpensive, small, heterogeneous, resourceconstrained, possibly embedded, highly-distributed, and highly-mobile computing platforms. We refer to software development in this new setting as programming-in-the-small-and-many (Prism). This paper provides a description and evaluation of a middleware intended to support software architecture-based development of applications in the Prism setting. The middleware provides implementation-level support for the key aspects of Prism application architectures: components, connectors, architectural configurations, and communication events. Additionally, the middleware directly facilitates several system qualities necessitated by Prism, including light weight, distribution, mobility, context awareness, asynchrony, and support for disconnected operation. Our middleware has been applied successfully in a number of applications and used as an educational tool in a graduate-level embedded systems course. Recently, the middleware has been successfully evaluated by a major industrial organization for use in one of their key distributed embedded systems. While a number of issues remain to be explored, our experience with the middleware thus far has been very positive, indicating that the principles of architecture-based software development can be successfully applied in the Prism setting.

Added October 29th, 2002


USC-CSE-2002-500

Nenad Medvidovic, Nikunj R. Mehta, Marija Mikic-Rakic, "A Family of Software Architecture Implementation Frameworks," Proceedings of the 2002 Working IEEE/IFIP Conference on Software Architectures (WICSA-3), Montreal, Canada, August 25-30, 2002, pp. 221-235 (pdf)

Software architectures provide high-level abstractions for representing the structure, behavior, and key properties of software systems. Various architecture description languages, styles, tools, and technologies have emerged over the past decade. At the same time, there has been comparatively little focus on techniques and technologies for transforming architectural models into running systems. This often results in significant differences between conceptual and concrete architectures, rendering system evolution and maintenance difficult. Furthermore, it calls into question the ability of developers to consistently transfer the key architectural properties into system implementations. One solution to this problem is to employ architectural frameworks. Architectural frameworks provide support for implementing, deploying, executing, and evolving software architectures. This paper describes the design of and our experience with a family of architectural frameworks that support implementation of systems in a specific architectural style-C2. These frameworks have been implemented in different programming languages and used on different hardware platforms, including resource constrained (e.g., hand held) devices. The frameworks are lightweight and extensible, and allow application monitoring and analysis at run time. To date, the C2 frameworks have been used in the development of over 100 applications by several academic and industrial organizations. The paper discusses the issues we have encountered in implementing and using the frameworks, as well as the approaches adopted to resolve these issues.

Added March 14th, 2002


 

Copyright 2008 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.