Monday, June 5 2000

T01:    Software Cost Estimating with the COCOMO II Model

Donald J. Reifer, University of Southern California

Monday, June 5 2000, 9:00 - 18:00

This one-day workshop introduces participants to the subject of software economics. Emphasis is placed on developing software cost estimating skills using the newly released COCOMO II-2000 model. Use of the models for developing estimates, performing "what-if" analysis, bounding risks, and conducting a variety of trade studies is also highlighted. The seminar uses a variety of examples, case studies, and hands-on exercises to develop estimating skills, knowledge and abilities. It generates example cost model runs using both the USC and COSTAR packages.

T02: Specifying and Measuring Quality in Use

Nigel Bevan, Serco Usability Services

Monday, June 5 2000, 9:00 - 18:00

The tutorial explains how quality in use can be operationalized as the prime quality goal for a system. Quality in use is the extent to which a system meets the operational requirements of end users. It is measured by effectiveness, productivity, safety and satisfaction, and is the combined effect for the end user of the functionality, efficiency, usability and reliability. The new model for software quality in ISO/IEC 9126-1 can be used to incorporate quality in use into system development.

The tutorial is based on the contents of ISO/IEC TR 9126-4: Quality in Use Metrics (the presenter is editor of ISO/IEC 9126-1 and 9126-4). It includes use of the methodology originally developed by the collaborative European MUSiC (Measurement of Usability in Context) project. Participants will learn how to use MUSiC methods, and how the US Common Industry Format can be used to specify usability and quality in use requirements, and to report quality in use results.

T03:    Designing and Analyzing Software Architectures using ABASs

Rick Kazman, Software Engineering Institute, Carnegie Mellon University

Monday, June 5 2000, 9:00 - 12:45

This tutorial will discuss, exemplify, and involve the students in the use of Attribute-Based Architectural Styles (ABASs) - architectural styles accompanied by explicit analysis reasoning frameworks - in both the design and analysis of software and system architectures. The tutorial has several objectives: to introduce the students to a catalog of ABASs covering performance, availability, security, modifiability, and usability; to convince students that ABASs provide a basis for insightful reasoning about a software architecture’s ability to meet its quality attribute goals; to demonstrate the utility of ABASs by showing examples of how ABASs are used to design and analyze real-world system architectures; and to give the students some experience with using ABASs directly. We will present some large excerpts from our growing ABAS handbook and show that ABASs help us in designing architectures efficiently and predict-ably and in quickly finding architectural risks and tradeoffs when doing analysis.

T04     Building Modular OO Systems with Reusable Collaborations

Karl Lieberherr, Northeastern University and UBS AG

Monday, June 5 2000, 9:00 - 12:45

Collaborations are a practical approach to avoid tangling of concerns that should be separated in OO development. One way to develop a system is to start with use cases, realize them as collaborations, code them as collaborating classes and deploy them in an application. This tutorial shows participants how to use collaborations and describes tools to facilitate their use in practice. Participants will learn how to use collaborations to address some important problems in their specification, design and implementation activities. They will also learn how to use collaborations to facilitate the use of design patterns and aspect-oriented designs and programs.

T05:    Introduction to CORBA

Steve Vinoski, IONA Technologies

Monday, June 5 2000, 9:00 - 12:45

This tutorial provides the basics that developers need to begin understanding CORBA and using it to write industrial-strength distributed systems. You will learn about the basics of the OMG's Object Management Architecture (OMA), with a focus on its CORBA component. By the end of the tutorial, you will understand how to write object interface specifications using the OMG Interface Definition Language (IDL), how to write simple distributed applications in C++, how to use the new Portable Object Adapter (POA), the Dynamic Invocation Interface (DII) and the Dynamic Skeleton Interface (DSI), and the Interface Repository (IFR). You will also know the basics of several CORBA services such as Naming, Trading, and Events.

T06:    Moving from ISO9000 to High Maturity Levels of the CMM

Pankaj Jalote, I. I. T. Kanpur

Monday, June 5 2000, 9:00 - 12:45

There are a large number of software developing organizations in the world that are ISO9001 certified. Many of these are now considering adopting the SEI's Capability Maturity Model (CMM), which provides a basis for process management and improvement. In this transition from ISO9001 to CMM, processes have to be enhanced to suit the CMM (while preserving ISO9001). This tutorial discusses the typical enhancements that might be needed by an ISO organization when moving to higher levels of maturity in the CMM framework, how to leverage ISO structures and practices for implementing CMM, and how to manage the transition.

This tutorial is based on the experience of the author in spearheading the transition from ISO9000 to CMM of Infosys, a large Bangalore-based software organization, and in helping some other organizations in transitioning. It is intended for members of those organizations that are ISO-certified, or are going for ISO certification, and who wish to consider moving to the CMM. It will also be of interest to professionals interested in these models.

T07:    Planning Realistic Schedules Using Software Architecture

Robert L. Nord, Siemens Corporate Research
Daniel J. Paulish, Siemens Corporate Research
Dilip Soni, Siemens Corporate Research

Monday, June 5 2000, 14:15 - 18:00

Software architecture forms the organizational plan for development. This tutorial introduces the concepts of architecture design and shows how they can be used in software project planning to better plan and manage software projects. By applying the architecture-centered approach described in this tutorial, we believe that projects can be planned within a schedule estimation error of 15-20%. A software architecture design document is the primary input to the top-down and bottom-up planning processes, and a software development plan is the primary output. Each development team member uses the software development plan for generating a personal schedule with weekly milestones for the components that they are developing. In addition, there is an overall project schedule monitored by the project manager that identifies how the components are allocated to the incremental releases. The approach is best applied when the high-level design is complete and the development team is staffed. It helps transfer the design knowledge to the team members and builds buy-in of the schedule.

As a participant in this tutorial, you will learn how architecture-centered software project planning can be used to help plan and manage software projects. This approach has been applied to several projects and we will share our experience on how this works in practice. We will work through an example based on a real system and ask you to participate in a couple of exercises. You will also learn about the critical roles of the project manager, software architect, and team members in making this process successful.

T08:    Improving Design and Source Code Modularity Using AspectJ

Cristina Lopes, Xerox PARC
Gregor Kiczales, University of British Columbia

Monday, June 5 2000, 14:15 - 18:00

Aspect-oriented programming (AOP) can be used to improve the modularity of a wide range of software. Using only traditional techniques the implementation of concerns like exception handling, multi-object protocols, synchronization constraints, and security policies tends to be spread out in the code. The lack of modularity for these concerns makes them more difficult to develop and maintain. This tutorial shows how to use AOP to implement concerns like these in a concise modular way. We will discuss the effect aspects have on software design and on code modularity. The concrete examples in the tutorial use AspectJ, a freely available aspect-oriented extension to the Java(tm) programming language.

T09:    Scalability Issues in CORBA-based Systems

Steve Vinoski, IONA Technologies

Monday, June 5 2000, 14:15 - 18:00

This tutorial addresses how both the OMG specifications and the implementation choices made by middleware providers and application developers affect application scalability. We will cover a range of scalability issues, starting with ORB internals and working outward to full-scale applications, addressing issues such as connection management, POA scalability features, multithreading, object lifecycle issues, object location, system configuration, maintenance, and management, and common application architectures. This tutorial is not language-centric and is useful to developers using Java, C++, or any other language to develop CORBA-based applications.

T10:    Intellectual Property Protection for Software in the United States and Europe: The Changing Roles of Patents and Copyrights

Gregory J. Kirsch, Needle & Rosenberg, P.C.
Yannis Skulikaris, European Patent Office

Monday, June 5 2000, 14:15 - 18:00

Intellectual Property (IP) is expected to play an increasingly important role in the coming years. IP laws evolve not just on a national or regional basis, but also globally, influenced by the growing importance of technology and international trade. Moreover, certain IP laws—and specifically patent law—have been steadily expanding to cover emerging technologies, such as computer software, and more recently automated business methods. At the same time, the legal protection afforded by other types of IP laws—namely copyright protection—has been narrowed in recent years, resulting in a dramatic shift in how software developers are seeking to protect their innovation. Specifically, there has been an explosive shift to patents as a primary mechanism for legally protecting software and Internet-related inventions. This tutorial will shed light regarding the important changes that are occurring in the IP laws in the United States and Europe, and how companies and other institutions are taking advantage of and responding to these changes.

Tuesday, June 6 2000

T11:    Software Process Improvement: Best Practices and Lessons Learned

Bill Curtis, TeraQuest Metrics

Tuesday, June 6 2000, 9:00 - 18:00

This tutorial will provide an excellent opportunity for anyone wishing to learn more about how to improve their software operations. The tutorial will begin by discussing the problems in software development that are solved by SPI programs, and will later describe problems whose solutions are enabled by SPI, even though the solutions must emerge from technical activities. The tutorial will describe the results achieved in successful SPI program over the last decade, but will focus heavily on results emerging in the last couple of years from companies like Ericsson, Boeing, Tata, Lockheed Martin, and Telcordia Technologies. A brief comparative description of SPI models such as CMM and SPICE will be provided. The tutorial will then review the critical success and failure factors that have emerged from SPI programs over the last decade. In particular, 10 known failure conditions SPI programs frequently experience will be described. Responsibilities in SPI programs for executives, managers, process groups, and developers will be described. A new paradigm for conducting SPI programs that has been designed to avoid many of the pitfalls will be described. SPI’s relevance to internet software and outsourcing will be discussed. Participants will be given frequent opportunities to question and interact with the instructor.

T12:    Commonality Analysis for Defining Software Product Lines

Mark Ardis, Bell Laboratories, Lucent Technologies

Tuesday, June 6 2000, 9:00 - 12:45

A recent trend in both the software engineering research and industrial communities has been to seek ways to systematically engineer software domains. Rather than design and construct software products individually, a product line is designed that allows variation between products to meet individual requirements. This tutorial teaches the commonality analysis process, a systematic approach to analyzing families of software systems. The result of the analysis forms the basis for designing reusable assets that facilitate rapid production of new products within the software product line. Participants will learn the principles underlying the approach and will perform a practice commonality analysis guided by an experienced user of the process.

T13:    Designing Real-Time and Distributed Applications with the UML

Hassan Gomaa, George Mason University

Tuesday, June 6 2000, 9:00 - 12:45

This tutorial describes the object-oriented analysis and design of concurrent applications, in particular real-time, client/server, and distributed applications. Object-oriented concepts are crucial in software analysis and design because they address fundamental issues of adaptation and evolution. With the proliferation of notations and methods for the object-oriented analysis and design of software systems, the Unified Modeling Language (UML) has emerged to provide a standardized notation for describing object-oriented models. However, for the UML notation to be effectively applied, it needs to be used in conjunction with an object-oriented analysis and design method.

Most books and courses on object-oriented analysis and design only address the design of sequential systems or omit the important design issues that need to be addressed when designing real-time and distributed applications. It is essential to blend object-oriented concepts with concurrency concepts to successfully design these applications. As the UML is now the standardized notation for describing object-oriented models, this tutorial uses the UML notation throughout.

T14:    System Development Using Application Services over the Net

Kenji Takahashi, NTT
Anthony Finkelstein, University College London
Wolfgang Emmerich, University College London
Sofia Guerra, University College London

Tuesday, June 6 2000, 9:00 - 12:45

This tutorial explores how application service provision (ASP) is changing the software development landscape in terms of technology, methodology and economics. ASP is a type of commercial service offering that allows users to use computer applications hosted by the service providers at their premises over network. The promise of ASP is that by using application services over the Net (internet, intranet, and/or extranet), a significant part of system requirements can be met with, it is suggested, little need for initial development and recurring in-house maintenance effort.

The goal of this tutorial is to give participants a detailed understanding of the prospects for, and issues arising from, the emerging ASP industry. In this tutorial, we give an overview of the ASP industry and illustrate how ASP works in real settings using case studies. We discuss methods to make effective use of ASP (e.g. specification and selection of services), examine enabling technology (e.g. technical standards), and explore the key challenges (e.g. security and performance).

T15:    Software Reliability: Basic Concepts and Assessment Methods

Bev Littlewood, Centre for Software Reliability, City Univ., London
Lorenzo Strigini, Centre for Software Reliability, City Univ., London

Tuesday, June 6 2000, 9:00 - 12:45

This half-day tutorial introduces the need for probabilistic measures of software dependability, and the basic principles, capabilities and limitations of the methods for assessing and predicting them. The topics covered include: the basic concepts of reliability; principles of statistically realistic testing; estimation of stable reliability; "reliability growth models" and ways for checking their trustworthiness; limits to reliability levels that can be effectively demonstrated before deployment of the software. The tutorial is designed for an audience with a software engineering background, with only a knowledge of the basic concepts of probability. It is meant to give an understanding of the meaning and value of claims about software reliability, and of the practical methods available for predicting it.

T16:    Product-line Architectures, Aspects, and Reuse

Don Batory, University of Texas at Austin

Tuesday, June 6 2000 – 14:15 - 18:00

This half-day (3 hour) tutorial explains practical techniques for designing and building product-line architectures (i.e., families of applications) from components and how to design architecturally evolvable software (i.e., software that evolves through the addition and removal of components). We present a model of product-line architectures that brings together significant areas of research in software design: aspect-oriented programming, Perry's lightweight semantics for validating architectural consistency, parameterized programming, and generative programming. Among the practical case-studies we review are building extensible Java compilers (i.e., a product-line of Java dialects) and extensible simulators for Army fire support. The tutorial assumes rudimentary knowledge of OO concepts, but no experience with the tutorial's subject.

T17:    Advanced Visual Modeling: Beyond UML

Joseph Gil, Technion, The University, Canterbury
John Howse, University of Brighton
Stuart Kent, The University, Canterbury

Tuesday, June 6 2000 – 14:15 - 18:00

With the adoption of UML by the OMG and industry as the standard visual modeling notation, it is interesting to wonder what will come next in this field? This tutorial presents a vision for visual modeling beyond UML. It is based on a series of recent research papers, which have introduced some radical new notations and which have suggested the kinds of tools that could be available to support the modeler of the future. Highlights include: A crash critical overview in UML, stressing its weaknesses and strengths; a rich visual constraint language and an insight into subtle issues that arise when defining a visual language, for applying the popular design-by-contract using a visual formalism; and a demonstration of a graphical editor for the constraint-diagrams language.

T18:    Understanding Code Mobility

Gian Pietro Picco, Politecnico di Milano

Tuesday, June 6 2000 – 14:15 - 18:00

Code mobility allows a distributed application to relocate its components at run-time. This approach, made popular by Java and a myriad of other languages and systems, exhibits the potential for changing radically the way distributed applications are developed and deployed. Nevertheless, the research area is still quite immature, and there is a strong need for a systematic approach towards understanding the key characteristics of code mobility as well as for a careful analysis of the benefits provided.

The tutorial will provide a conceptual framework for code mobility by illustrating a taxonomy of mobile code technologies, architectural paradigms, and applications. The taxonomy will provide a terminological basis, as well as a precise characterization of the founding concepts of the research area. As a final case study, the concepts developed in the taxonomy will be applied to a quantitative assessment of the benefits of mobile code technologies and paradigms in the network management application domain.

T19:    Fault Tolerance Via Diversity Against Design Faults: Design Principles and Reliability Assessment

Bev Littlewood, Centre for Software Reliability, City Univ., London
Lorenzo Strigini, Centre for Software Reliability, City Univ., London

Tuesday, June 6 2000 – 14:15 - 18:00

Design faults account for a large part of failures in mature software-based products. Fault tolerance, employing redundant, diverse software component, has been used for many years as a defense. Though commonly associated with safety-critical real-time systems, its principles are applicable to all kinds of software designs. While the idea is attractive, the use of diversity has been vehemently attacked. Most practitioners for whom software fault tolerance could be a viable choice have little information for decisions about its use.

This half-day tutorial introduces both the methods of fault-tolerant software design, with examples from industrial practice and from research, and the problem of estimating the reliability gain from fault-tolerant design. This estimation is as difficult as for other software engineering methods. The tutorial explains the basic results so far, clarifies the terms of decisions about using software fault tolerance, and outlines recent progress in research. The tutorial is designed as an introduction to this topic for an audience with an experience in software engineering and an understanding of the basic concepts of software reliability.

T20:    Improving Software Inspections by Using Reading Techniques

Victor Basili and Forrest Shull, with Iona Rus and Oliver Laitenberger, Fraunhofer Center for Experimental Software Engineering, Maryland, and Fraunhofer Institute for Experimental Software Engineering (IESE), Germany

Tuesday, June 6 2000 – 14:15 - 18:00

This tutorial introduces Perspective-Based Reading (PBR), a specific reading technique used to review software requirements documents. The specific goals of this tutorial are: to describe a set of techniques that can increase the effectiveness of software inspections, by providing individual inspectors with systematic techniques to read a software artifact and recognize defects; to provide participants with the opportunity to apply PBR while being able to ask questions or ask for assistance from the instructors; to demonstrate to the participants how to tailor the PBR technique to their development environment; to discuss how participants can assess inspections in their own environments. This tutorial aims at industry practitioners, managers and developers alike, who want to learn more about ways to improve their software inspections with systematic reading techniques. Attending this tutorial will enable the participants to be more effective and more focused in looking for potential defects in software documents.