Tutorials
On this page:
- Sunday, May 13, 2001
(full-day, morning, and afternoon tutorials)
- Monday, May 14, 2001
(full-day, morning, and afternoon tutorials)
- Tuesday, May 15, 2001
(full-day, morning, and afternoon tutorials)
|
Sunday, May 13, 2001
Full-Day Tutorials
T1
UML for Software Engineers
Robert France,
Colorado State University, USA; and
Cris Kobryn,
Telelogic, Inc., USA
Contact:
Robert France
france@cs.colostate.edu
This tutorial assists participants in developing an understanding of UML with respect to its use for modeling software requirements and designs. The tutorial targets attendees familiar with basic object-oriented modeling principles and concepts. It covers both basic and some advanced features of the UML and gives an overview of efforts directed at restructuring UML to support the view of UML as a family of languages. A roadmap outlining the planned evolution of the UML is presented.
Sunday, May 13, 2001; 8:30 a.m.–5:30 p.m.
T2
The Intertwining between Risk and Project Management
Karol Frühauf,
INFOGEM AG, Switzerland
Contact:
Karol Frühauf
Karol_Fruehauf@compuserve.com
This is a tutorial from a practitioner for software practitioners, especially software project leaders, software managers and software quality engineers. The participants should have some project experience in order to benefit fully from the material. Familiarity with process models for software development and with project management techniques is advantageous. Participants will learn how to integrate risk assessment principles and techniques with software project planning and controlling. The fundamental problems of software project management like what is a project (and not a process or a product) and what are the tasks of project management in this context are discussed. A thorough, practical approach to risk management presented. The main focus is the intertwining of project and risk management into a coherent planning and controlling process.
Sunday, May 13, 2001; 8:30 a.m.–5:30 p.m.
Sunday, May 13, 2001
Morning Tutorials
T3
Methods of Component-Based Software Engineering: Essential Concepts and Classroom Experience
Kurt Wallnau,
Carnegie Mellon Software Engineering Institute, USA
Contact:
Kurt Wallnau
kcw@sei.cmu.edu
The need for component-based development methods has become more pronounced as industry adopts software component technology. However, the idea of component is not monolithic; different forms of a software component introduce different engineering challenges. This tutorial provides an overview of "component space" and the methods that populate this space. Two classes of component-based design methods are discussed in detail: one where the task is to specify component interfaces, the other where components exist a priori from a commercial provider and must be integrated. The tutorial also describes a CMU Master of Software Engineering course focused on component-based methods and taught by the presenter. The design of team projects and their results are presented, along with lessons learned that may prove useful to other instructors.
Sunday, May 13, 2001; 8:30 a.m.–12:00 p.m.
Sunday, May 13, 2001
Afternoon Tutorials
T4
From Use Cases to Code—Rigorous Software Development with UML
Albert Zündorf,
University of Paderborn, Germany
Contact:
Albert Zündorf
zuendorf@uni-paderborn.de
The Rational Unified Process lacks technical guidance for the development of OO applications. This tutorial fills this gap. We first use UML scenario diagrams to analyze use-cases. Next, we show a method to analyze scenarios and to derive UML class diagrams and UML behavior modeling for active classes and methods. We show how to choose and embed design patterns in a design and how to employ different architectural styles. From such a precise design, smart CASE tools generate fully functional implementations. We explain state-of-the-art code generation concepts for UML and assess current CASE tools for their code generation capabilities and for their support through all software development phases more generally.
Sunday, May 13, 2001; 2:00 p.m.–5:30 p.m.
Monday, May 14, 2001
Full-Day Tutorials
T5
OPEN: A Flexible OO/CBD Process for Software-Intensive Systems Development, a UML Exposition
Houman Younessi,
Rensselaer Polytechnic Institute at Hartford, USA; and
Brian Henderson-Sellers,
Swinburn University of Technology, Australia
Contact:
Houman Younessi
houman@rh.edu
The increased complexity associated with large-scale software-intensive systems development requires an increase in the sophistication of the methodology utilized. Following a general discussion on the value of processes, one specific OO/CBD example, OPEN (Object-oriented Process, Environment and Notation) is described in detail. Emphasis will be placed upon the need for flexibility of processes and how they can be constructed and configured to individual circumstances. Some advice on how to transition to OO/CBD and deploy this process for the first time will be given.
In addition, and using OPEN as the background process, the UML (Unified Modeling Language) is introduced through a number of case study examples. Modeling and notational issues of the UML are discussed at an introductory level, set in the relevant context of OPEN's modeling tasks and techniques.
Monday, May 14, 2001; 8:30 a.m.–5:30 p.m.
T6
Describing Software Architecture with UML
Phillippe Kruchten and
Bran Selic,
Rational Software Canada Corporation, Canada; and
Wojtek Kozaczynski,
Rational Software, Inc., USA
Contact:
Phillippe Kruchten,
pbk@rational.com
The presence of a solid architectural vision is a key discriminator in the success or failure of a software project. This tutorial examines what software architecture is and what it is not. It discusses and illustrates how to describe architecture through a set of design viewpoints and views and how to express these views in the UML, in the spirit of the new IEEE Standard 1471:2000: recommended practice for architectural description. The tutorial shows of how architectures drive the development process and how to capture architectural design patterns using the UML. It is illustrated by several widely applicable architectural patterns in different domain.
Monday, May 14, 2001; 8:30 a.m.–5:30 p.m.
T7
Software Product Lines and Software Architecture Design
Jan Bosch,
University of Groningen, The Netherlands
Contact:
Jan Bosch
Jan.Bosch@cs.rug.nl
One can identify two important developments in software architecture, i.e. software product lines and software architecture design. This tutorial addresses these topics by presenting a method for architectural design explicitly focussing on assessment of and transformation for quality attributes. In addition, the notion of software product lines and the process, technology, business and organizational issues of adopting the approach are presented. Examples and experiences from numerous industrial cases are used to extensively illustrate both design and product-lines. This intermediate-level tutorial is based on a recently published book: Design and Use of Software Architectures—Adopting and Evolving a Product Line Approach, authored by the tutorial presenter and published by Addison-Wesley.
The expected audience is of two types: software engineers and technical managers considering the introduction of software architecture design and, potentially, product-line architectures in their organization, and researchers interested in the experiences and reflections of the presenter on this subject.
Monday, May 14, 2001; 8:30 a.m.–5:30 p.m.
Monday, May 14, 2001
Morning Tutorials
T8
How to Do Inspections When There is No Time
Terry Shepard and
Diane Kelly,
Royal Military College, Canada
Contact:
Terry Shepard
shepard@rmc.ca
Research shows that software inspections are an effective, essential part of software development. Yet, according to some industry practitioners, inspections are difficult, costly, ineffective, and excessively time consuming. So what’s gone wrong? The most likely answer is extreme pressure on resources, and above all, on schedules.
Organized around the 3Ms of inspection, Management, Mechanics, and Metrics, this tutorial provides a toolkit of ideas to help you effectively tailor inspections to suit your software process. Whether your focus is personal, small group, or large group, a variety of new, lightweight, flexible inspection approaches are available.
This tutorial provides background information for the novice and discusses new material of interest to both novices and experienced inspection practitioners. It will include a case study and an analysis of how the case study can be adapted to other situations. Opportunities for questions and discussions will be provided throughout.
Monday, May 14, 2001; 8:30 a.m.–12:00 p.m.
T9
EasyWinWin: A Groupware-Supported Methodology For Requirements Negotiation
Barry Boehm,
University of Southern California, USA;
Paul Grünbacher,
Johannes Kepler University, Austria; and
Robert O. Briggs,
GroupSystems.com, USA
Contact:
Paul Grünbacher
pg@sea.uni-linz.ac.at
EasyWinWin is a requirements definition methodology that builds on the win-win negotiation approach and leverages collaborative technology to improve the involvement and interaction of key stakeholders. With EasyWinWin, the stakeholders move through a step-by-step win-win negotiation where they collect, elaborate, and prioritize their requirements, and then surface and resolve issues.
This tutorial introduces the EasyWinWin negotiation approach and situates it with respect to other leading requirements determination approaches, and within the spiral model of software development. We explain the objectives and deliverables of each step in the methodology, and offer tips and pitfalls from the field. We give a live demonstration of the collaborative tools and the methodology in action, and demonstrate facilitation techniques that keep the process moving forward. Throughout the tutorial, we will present the highlights from several real-world EasyWinWin projects.
The intended audience are those professionals involved in requirements definition (e.g. as project managers, engineers, executives, users, customers); software requirements engineering researchers The level of presentation is introductory with no specific background knowledge required.
Monday, May 14, 2001; 8:30 a.m.–12:00 p.m.
T10
Fundamental Concepts for Practical Software Architecture
Alexander Ran,
Nokia Research Center, USA
Contact:
Alexander Ran
alexander.ran@nokia.com
Architecture of software is a collection of design decisions that are expensive to change. How to identify which design decisions are expensive to change? What are architecture views and which views are needed to adequately describe the architecture of a specific system? How to create and manage software architecture for a product family? This tutorial will provide an answer to these and other questions that arise in the context of complex software development.
We introduce a system of concepts useful in order to understand, design, and evaluate architecture of software intensive systems and system families. Our approach utilizes different software structures in order to control important system qualities related to its development, performance, and evolution. We draw our experience primarily from software embedded in voice and data communication systems. However the same principles can be applied to software architecture in other domains. This tutorial should be useful to software engineers and technical managers involved in construction or evaluation of complex software.
Monday, May 14, 2001; 8:30 a.m.–12:00 p.m.
T11
An Introduction to Java 2 Micro Edition (J2ME): Java in Small Things
James White,
Catapult Technologies, Inc., USA
Contact:
James White
jwhite@catapult-technologies.com
This tutorial is intended to be an introduction to the Java 2 Micro Edition (J2ME) for software engineers. J2ME is Sun’s latest Java 2 platform and is meant for consumer electronics and embedded devices. An exploration of the technology as well as an introduction to programming in the J2ME environment is undertaken.
The tutorial is divided into two major sections. The first section provides a general understanding of J2ME. Included in this half are discussions on J2ME's reason for being, architecture, and configurations/profiles --the specifications that really define J2ME.
The second half focuses on developing applications in the various J2ME configurations/profiles. The various J2ME APIs are compared and contrasted with programming examples to the more familiar Java 2 Standard Edition (J2SE).
To understand this tutorial, some knowledge of Java programming is helpful but not required.
Monday, May 14, 2001; 8:30 a.m.–12:00 p.m.
Monday, May 14, 2001
Afternoon Tutorials
T12
Improving Software Inspections by Using Reading Techniques
Forrest Shull and
Ioana Russ,
Fraunhofer Center for Experimental Software Engineering, USA; and
Victor R. Basili,
University of Maryland and Fraunhofer Center for Experimental Software Engineering, USA
Contact:
Forrest Shull
fshull@fc-md.umd.edu
Reading techniques are step-by-step procedures that guide individual inspectors while they uncover defects in a software artifact. Reading techniques provide a systematic and well-defined way of inspecting a document, allowing feedback and improvement. This tutorial introduces Perspective-Based Reading (PBR), a specific reading technique used to review software requirements. PBR verifies the quality of requirements specifications by requiring each reviewer to take the perspective of a specific stakeholder of the document (such as designer, tester, and user).
The tutorial is aimed 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. Since the focus of the tutorial is on systematic reading techniques for defect detection, it is beneficial for participants to have some basic understanding about software inspections.
Monday, May 14, 2001; 2:00 p.m.–5:30 p.m.
T13
Mining Components for a Software Architecture and a Product Line: The Options Analysis for Reengineering (OAR) Method
Dennis Smith,
Liam O’Brien, and
John Bergey,
Carnegie Mellon Software Engineering Institute, USA
Contact:
Dennis Smith
dbs@sei.cmu.edu
This tutorial discusses the problem of identifying components from legacy systems and determining which components will be useful for insertion in a new architecture, particularly in a product line architecture. Specifically, it outlines Options Analysis for Reengineering (OAR), a systematic method for evaluating the feasibility and benefits of mining existing components for a product line. OAR operates like a funnel in which a large set of potential assets is screened out so that the effort can most efficiently focus on a smaller set that most effectively meet the technical and programmatic needs of the product line or target architecture. The method provides a set of scalable techniques and exercises to collaboratively analyze existing components, determine viable mining options, and select the most promising option. It provides a structured approach to determine the cost, effort, and risk of mining a set of components from legacy systems. The tutorial is appropriate for researchers and advanced practitioners who are faced with making decisions on mining legacy components.
Monday, May 14, 2001; 2:00 p.m.–5:30 p.m.
T14
Hyper/J™: Multidimensional Separation of Concerns for Java™
Peri Tarr and
Harold Ossher,
IBM T. J. Watson Research Center, USA
Contact:
Peri Tarr
tarr@watson.ibm.com
Hyper/J™ supports a new approach to constructing, integrating and evolving software, called Multi-Dimensional Separation of Concerns (MDSOC). Developers can decompose and organize code and other artifacts according to multiple, arbitrary criteria (concerns) simultaneously—to some extent even after the software has been implemented—and synthesize or integrate the pieces into larger-scale components and systems.
This tutorial describes how to accomplish MDSOC with Hyper/J™, a tool available for free download, in the context of standard Java™ development. The focus is on addressing some real, pervasive problems, especially in the areas of evolution, integration, reuse, and (re)use of design patterns, and showing how to encapsulate concerns like features, variants, roles and business rules.
The tutorial is at an intermediate-level and combines presentation with interactive exploration of examples. Participants have the opportunity to select examples from a prepared set, and to contribute their own. Attendees must have experience with object-oriented software engineering, and some familiarity with Java™.
Monday, May 14, 2001; 2:00 p.m.–5:30 p.m.
T15
Enterprise JavaBean Architecture and Design Issues: Avoiding JavaBean Soup
James White,
Catapult Technologies, Inc., USA
Contact:
James White
jwhite@catapult-technologies.com
Enterprise JavaBeans (EJB) have become a staple in distributed object and component architectures. However, like most technologies, EJB provides technology tradeoffs that must be weighted by the architect contemplating its use. Furthermore, like most technologies, EJB cannot save a poor system design.
This tutorial is separated into two general sessions. The first half of the tutorial covers the larger "macro" architectural decisions surrounding EJB, such as decisions about whether EJB technology is right for a project and selecting an appropriate EJB server.
The second half of the tutorial focuses on issues in bean design. These "micro" issues include: where to use entity versus session beans, when to use container versus bean managed persistence, the granularity of EJBs, and the impact of the underlying database on bean design.
This session is intended for architects, analyst and developers examining or working with EJB technology. Attendees are expected to have some familiarity with EJB terminology and technology.
Monday, May 14, 2001; 2:00 p.m.–5:30 p.m.
Tuesday, May 15, 2001
Full-Day Tutorials
T16
State, Event, Time and Diagram in System Modeling
Jin Song Dong,
National University of Singapore, Singapore
Contact:
Jin Song Dong
dongjs@comp.nus.edu.sg
The design of complex systems requires powerful mechanisms for modeling data, state, concurrency, and real-time behavior; as well as for structuring and decomposing systems in order to control local complexity. Method integration has become a recent research trend in software specification and design. In the graphical area, many object-oriented methods have merged into one, the Unified Modeling Language (UML) which combines various diagrammatic modeling techniques to model static and dynamic aspects of software systems. Although traditional formal methods have not scale-up well, new integrated formal methods show great promise. This tutorial will present the state of the art in formal modeling techniques (state-based Object-Z and event-based Timed CSP), their integration (TCOZ), and transformation techniques from the integrated formalism to UML. An XML web environment for projecting integrated formal models to UML diagrams will also be demonstrated.
The tutorial material contains both introductory and intermediate level and should be of interest to software designers, software engineers, as well as software engineering researchers and graduate students.
Tuesday, May 15, 2001; 8:30 a.m.–5:30 p.m.
T17
From UML to Java: Building a 3-Tier Architecture
Timothy Korson,
Southern Adventist University, USA
Contact:
Timothy Korson
korson@southern.edu
The successful use of object technology requires far more than simply the adoption of UML, Java, CORBA or COM. What is crucial, is knowing how to use these technologies to build commercially robust software systems. In this session the speaker draws on his experience at NASA, AT&T, IBM, and other leading companies to illustrate the pitfalls and best practices of component based software development.
The case study will explore the recent experience of the author in developing a multi-currency, multi-lingual financial application for an international organization. The focus of the tutorial will be on exploring the modeling, architecture, Java implementation, and database issues as well as the other design tradeoffs that were considered. Each design tradeoff is related to the system requirements and business goals.
Tuesday, May 15, 2001; 8:30 a.m.–5:30 p.m.
T18
Designing Concurrent, Distributed, and Real-Time Applications with UML
Hassan Gomaa,
George Mason University, USA
Contact:
Hassan Gomaa
hgomaa@gmu.edu
Object-oriented analysis and design of concurrent applications are described with particular emphasis on 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. To successfully design real-time and distributed applications, it is essential to blend object-oriented concepts with concurrent processing concepts. Although the Unified Modeling Language (UML) has emerged to provide a standardized notation for describing object-oriented models, for the UML notation to be effectively applied, it needs to be used in conjunction with an object-oriented analysis and design method, as presented in this tutorial. This tutorial is based on the instructor’s book: Designing Concurrent, Distributed, and Real-Time Applications with UML, Addison Wesley, 2000, http://www.aw.com/cseng/titles/0-201-65793-7.
Topics covered include OO requirements, analysis, and design modeling; distributed software architecture; component based distributed design; concurrent task structuring; design of message communication interfaces, including synchronous, asynchronous, brokered, and group communication; performance analysis of real-time designs.
This tutorial should be of interest to software professionals responsible for designing, implementing, or managing the design of concurrent applications. The material is presented for an intermediate level audience who have some familiarity with object-oriented and concurrency concepts.
Tuesday, May 15, 2001; 8:30 a.m.–5:30 p.m.
T19
Using Transformation Systems for Software Maintenance and Reengineering
Ira Baxter,
Semantic Designs, Inc., USA
Contact:
Ira Baxter
idbaxter@semdesigns.com
Software maintenance costs dominate software engineering costs, partly because most such engineering is done manually. Program transformation tools leverage an engineer-provided base of "transforms" (a kind of generative reuse of programming knowledge), to automate analysis, modification, and generation of software, enhancing productivity and quality over conventional methods. This tutorial provides a complete overview of Program Transformation, from theory to implementation to application. Several real transformation systems are examined, with application examples including automated detection and removal of duplicate code from large systems, and the potential for semi-automated refactoring of large object frameworks. The tutorial progresses from introductory to intermediate, but all the necessary background will be provided. Attendees need only have basic software engineering knowledge and motivating experience in modifying software. The presenter has been designing and using transformation systems for 20 years, and is the principal behind the DMS transformation system for large scale software reengineering.
Tuesday, May 15, 2001; 8:30 a.m.–5:30 p.m.
T20
Effective Software Architecture Design: From Global Analysis to UML Descriptions
Robert L. Nord,
Daniel J. Paulish, and
Dilip Soni,
Siemens Corporate Research, USA; and
Christine Hofmeister,
Lehigh University, USA
Contact:
Robert Nord
rn@sei.cmu.edu
It is now generally accepted that separating software architecture into multiple views can help in reducing complexity and in making sound decisions about design trade-offs. Our four views are based on current practice; they are loosely coupled, and address different engineering concerns. This tutorial will teach you how global analysis can improve your design, and how to use UML to describe these four views: the conceptual, module, execution, and code architecture views. You will also learn:
- the purpose of having separate software architecture views;
- the difference between using UML for software architecture and the use of UML for designing OO implementations;
- how to apply global analysis to analyze factors that influence the architecture and to develop strategies that guide the design;
- the importance of designing for anticipated change to produce more maintainable architectures;
- how to incorporate software architecture design and its artifacts in your software process.
The tutorial is aimed at experienced software engineers, architects, project and technical managers. It is assumed that participants know the basic UML diagram types. Experience in developing models and software design is helpful.
Tuesday, May 15, 2001; 8:30 a.m.–5:30 p.m.
Tuesday, May 15, 2001
Morning Tutorials
T21
Bridging the Requirements/Design Gap in Dynamic Systems with Use Case Maps (UCMs)
Daniel Amyot and
Gunter Mussbacher,
Mitel Corporation, Canada
Contact:
Gunter Mussbacher
gunter_mussbacher@mitel.com
Use Case Maps (UCMs) concepts, the UCM notation, and how UCMs fit into the software development process are presented. UCMs help bridge the requirements/design gap and provide dynamic (run-time) refinement capabilities for scenario/structure variations often characteristic of dynamic software systems (e.g. e-commerce applications). The tutorial will show how UCMs address functional requirements expressed in use cases and performance requirements as well as high-level design and testing. Exercises are provided for the participants along with a brief demonstration of the freely available UCM Navigator tool. The intended audience includes requirements engineers, system architects, test engineers, and software engineers with an interest in scenario-based system development and/or responsible for the development of dynamic systems. Participants will be assumed to have some experience in system modeling and be familiar with software development processes.
Tuesday, May 15, 2001; 8:30 a.m.–12:00 p.m.
Tuesday, May 15, 2001
Afternoon Tutorials
T22
Introduction to the Attribute Driven Design Method
Felix Bachmann and
Len Bass,
Carnegie Mellon Software Engineering Institute, USA
Contact:
Len Bass
ljb@sei.cmu.edu
The Attribute Driven Design (ADD) method is introduced. ADD is a method for designing the conceptual architecture for a product line. The conceptual architecture includes the decomposition of function for the final systems, identification of possible threads of parallelism, identification of possible physical network configurations and allocation of the functional decomposition to processors.
The ADD method is based on: 1) explicit identification of quality attribute goals for a system and 2) coupling these goals to architectural mechanisms and styles that are intended to achieve those goals. It treats quality goals as first class requirements on the level of functional requirements and makes explicit the dependence of architecture on quality and business requirements.
The ADD method can begin once architectural drivers (those requirements that shape the architecture) have been identified and this allows the architecture design to be carried on in parallel to the requirements process.
Tuesday, May 15, 2001; 2:00 p.m.–5:30 p.m.
