Monday 19 June 2000, Pre-Conference Tutorials

Morning 8:30-12:00 with 1/2 hour of break distributed as instructor sees fit.

T1: Using Non-Functional Requirements to Improve the Software Development Process

Complex information systems need conceptual models to deal with aspects
beyond the usual entity and activity framework. Recent research has
pointed out that conceptual models need to deal with goals, in order to
model complex situations that happen in the real world. Recent tales of
failure in information systems can be explained by the lack of
attention to non-functional requirements. The well-known case of the
London Ambulance System (LAS) is a good example. The LAS was
deactivated, soon after its deployment, because of many problems, many
of which were related to non-functional requirements such as
performance and conformance with standards. This tutorial intends to
show to the attendees not only how to deal with non-functional
requirements, but also a method to integrate them into the data model
that reflects functional needs. The tutorial shows that this
integration leads to a better understanding of the impacts that arises
when one decides to satisfy non-functional requirements. This tutorial
covers the Entity Relationship Model and the Unified Modelling Language
as data models. It shows that the use of the proposed method can lead
to lower software development costs and to fewer changes in the
software during maintenance. It presents some data collected in
different case studies. Considering non-functional requirements during
requirements elicitation leads to a final product that better matches
the clients' expectations.

This tutorial is intended for both industrial and academic software
engineers.

Julio Cesar Sampaio do Prado Leite - Associate Professor at the
Departamento de Informatica at PUC-Rio (Pontificia Universidade
Catolica in Rio de Janeiro). Elected member of the Brazilian Computer
Society council. Adjunct Professor of Information Systems at UERJ
(Universidade Estadual do Rio de Janeiro). Author/Co-Author of 13
journal papers and more than 50 articles for scientific conferences.
Associate Editor of Springer Verlag's Requirements Engineering Journal.
Project leader in a bi-national cooperation with Argentina. Leader of a
node in RENOIR, an Esprit network of excellence. Program committee
member of several international conferences. Reviewer for journals
including: IEEE Transactions on Software Engineering, IEEE Software,
Automated Software Engineering.

Luiz Marcio Cysneiros - Ph.D. Student at PUC-Rio. MS. in Computer
Science at PUC-Rio in 1997. 13 years working in computing, occupying
several positions, 6 of them as Manager of Informatics Bureau.
Author/Co-Author in 6 scientific conferences, 5 of then related to
Non-Functional Requirements. Masters thesis in Non-Functional
Requirements. Presented a Tutorial on Non-Functional Requirements in
the XIV Brazilian Symposium on Software Engineering.

There is considerable empirical evidence that a large proportion of the
problems with software intensive safety-related or safety-critical
systems arise from problems in requirements---mainly errors or
omissions. Against this background the tutorial will consider three
major issues:

-* techniques for writing requirements to help reduce safety-related
problems

-* techniques for hazard analysis at early stages in development to
help derive safety requirements

-* the evolution of (safety) requirements and designs during the
development process

The tutorial will introduce principles and techniques, and illustrate
these with examples drawn from real-world applications, e.g. aircraft
and automotive systems.

The intended audience is software or requirements engineers who are
interested in working on safety-related or safety-critical systems

John McDermid is professor of software engineering at the University of
York. He has been working on safety critical systems for about 15
years, and has run a research programme in systems, safety and software
engineering at York since 1987. He has strong working links with the
UK aerospace industry, running large research centres funded by BAE
SYSTEMS and Rolls-Royce which have made contributions to the design and
development of current and next generation aircraft and aero-engines.
He also works with companies in other industries, e.g. Daimler Chrysler
in automotive engineering, and Siemens in railway signalling. He is
the author or co-author of over 200 papers and 7 books.

This tutorial is addressed to requirements engineers and system
designers. It introduces the Abstract State Machine (ASM) method
for turning informal requirements into high-level system models,
sufficiently rigorous to be usable for an application-domain-based
analysis and validation and to be linkable in a coherent way to the
detailed design. Particular emphasis will be put on conveying the
experience which has been made with the method in industrial
requirements engineering projects where it helped to reduce the
development time for complex software as well as the cost for its
validation, documentation, maintenance and extension. The case
studies used in the tutorial are drawn from business applications,
from control software, and from hardware systems. The attendees will
learn a practical method to build rigorous, programming language and
platform independent models for complex systems which can serve as
link between informal requirements and more detailed UML diagrams and
statecharts or executable code.

The target audience is software engineers, in particular system
designers, both from industry and from accademia. The assumed
background is some practical experience with the problems of
requirements engineering and of building large software.

Egon Boerger from 1965-1971 studied philosophy, logic, and mathematics
in Paris (Sorbonne), Louvain (Belgium) and Muenster (Germany).
Doctoral degree (1971) and Habilitation (1976) in mathematics from the
university of Muenster. Lecturer and professor in logic and computer
science at the universities of Salerno (Italy) 1972-1976, Muenster
1976-1978, Dortmund (Germany) 1978-1985, Udine (Italy) 1982/83 and
since 1985 Pisa (Italy). Guest researcher in numerous universities in
Europe and US and at IBM Scientific Center (Heidelberg), Siemens
Corporate Research (Munich) and Microsoft Research (Redmond).
(Co)Author of four books and of over 80 research papers in logic and
computer science. Current research interests are in rigorous methods
and their industrial application for the design and the analysis of
hardware/software systems.

If you are struggling with how to do a Use Case or how to go from a Use
Case to requirements, this tutorial is for you. The tutorial will
address what can be covered by Use Case; some methods for doing Use
Case for your project; and techniques for going from Use Case to
Requirements and maintaining over the project life-cycle. Specifically,
the attendee will learn:

1. What exactly is Use Case

2. Where can it be applied

3. What do you need to know and who do you need to know to do Use Case

4. How to do different types of Use Case

5. Innovative ways to do and to record Use Case

6. How to take Use Case into requirements or other information to
reduce development and testing errors

Academia will benefit from seeing Use Case in a real-world setting and
Industry needs this tool to avoid missing and misinterpreting
requirements. Those with no experience should be able to pick this up
quickly. Those with much experience should gain some new insights.

Ivy Hooks is a nationally renowned expert in requirements development
and management who educates and consults organizations on the
importance of writing good requirements. She is a charter member of
INCOSE (International Council on Systems Engineering, a Fellow of the
Society of Engineers, and Associate Fellow of the AIAA, and a member of
IEEE. Ms. Hooks is currently president and CEO of Compliance
Automation, Inc. She has managed a small business for the past fifteen
years. She has provided training and consulting in requirements for
companies that include Rockwell-Collins, Lockheed-Martin, Hughes,
Raytheon, Kodak and Allied Signal and government organizations
including NASA, NOAA, FAA, and the Navy. Her seminars have been
presented across the United States, in Canada and in Great Britain.
Prior to her small business career, Ms. Hooks had a twenty year career
with NASA where she was Manager of Flight Software Development for the
Space Shuttle, Verification Manager of Flight Software for the Space
Shuttle, and Integration Manager for the Shuttle Separation Systems.
She also was a manager in the Shuttle Program Office, Executive
Assistant to the Director of Engineering, and Executive Assistant to
the Director of the Johnson Space Center. Ms. Hooks is the recipient of
the Washington D.C. Jaycees Arthur S. Flemming Award for outstanding
young civil servant, NASAs Exceptional Service Medal, NASAs Outstanding
Speaker Award, as well as many other awards. She currently resides in
the Texas hill country.

Requirements development and management have always been critical in
the implementation of software systemsengineers are unable to build
what analysts cant define. It is generally accepted that the earlier in
the life cycle potential risks are identified, the easier it is to
eliminate or manage the conditions that introduce that risk. Problems
that are not found until testing are approximately 14 times more costly
to fix than if the problem was found in the requirements phase. The
requirements specification, as the first tangible representation of the
capability to be produced, establishes the basis for all of the
projects engineering management and assurance functions. If the
quality of the requirements specification is poor it can give rise to
risks in all areas of the project. Recently, automated tools have
become available to support requirements management. The use of these
tools not only provides support in the definition and tracing of
requirements, but it also opens the door to effective use of metrics in
characterizing and assessing the quality of the requirement
specifications.

The Software Assurance Technology Center (SATC) supports the Office of
Mission Assurance at NASA Goddard Space Flight Center (GSFC). The SATC
developed this tutorial to help projects identify weaknesses in their
requirements and where they might not be testable based on data from
NASA and industry requirement documents. We will begin with a
discussion on requirements specification as a whole, looking at scope
and purpose. We will then go on to the structure of the document,
looking at standards available from various sources. The individual
requirement statements will be analyzed based on quality attributes
suggested by IEEE and other sources. We will conclude with a
discussion on requirement management, storage and metrics. The SATC
tool is available for free from the SATC homepage
http://satc.gefc.nasa.gov

This workshop will educate project managers and software developers in
effective development of quality requirement specifications. It will
also provide them with ideas and methods they can incorporate
immediately into their project plan and find a productive return in
documentation evaluation and comprehension.

The attendee will learn how to write requirements that are testable,
how to manage requirements, a little about requirement storage and
linkage, and how to measure various aspects of requirements, from
linkages, to test cases to quality.

The intended audience is project managers and software developers in
industry. Academics will also benefit. The tutorial assumes minimal
experience writing requirements, but the totally inexperienced will
also benefit.

Albert Gallo is an Engineering Section Head at Unisys Government
Systems in Lanham, MD. He is contracted to manage the Software
Assurance Technology Center (SATC) at Goddard Space Flight Center,
NASA, in Greenbelt, MD. Mr. Gallo has 15 years of Software Systems
Engineering and Quality Assurance experience and has experience in all
phases of Systems Development with an emphasis on database design. Mr.
Gallo holds Bachelors degrees in both Pure Mathematics and Computer
Science as well as an MS in Technical Management.

Dr. Linda H. Rosenberg is the Division Chief responsible for the
Software Assurance Technology Center (SATC) at Goddard Space Flight
Center, NASA. The SATC primary responsibilities are in the areas of
Metrics, Assurance tools and techniques, Risk management, and Outreach
programs. Although she oversees all work areas, Dr. Rosenberg's area
of expertise is metrics. The emphasis of her work with project
managers is the application of metrics to evaluate the quality of
development products. Dr. Rosenberg holds a Ph.D. in Computer Science,
an M.E.S. in Computer Science, and a BS in Mathematics.

Requirements Engineering has been around since the last 1960's.
Researchers and practitioners have argued for all this time that
requirements engineering is an essential part of the solution to our
industry's perennial problem of building ineffective or unusable or
inappropriate systems. And yet, during these same 40 years, our record
of success has changed little. Studies in the nineties show the same
as the studies of the sixties, i.e., 70% or more of the software
systems we build become shelfware. This tutorial will explore the
reasons for this failure and will point out that we are not doing
requirements engineering very well. One of the problems is that
requirements engineers spend little time and have little experience or
skill in performing requirements triage, i.e., the art of deciding
which requirements should be included in, and which should be excluded
from, a new product baseline. Without requirements triage, we end up
with a ``perfect set of requirements that do the wrong thing,'' also
called ``polishing the turd.'' Much of the tutorial with provide
``how-to'' guidance to tackle the tough problem of requirements
triage. Participants will learn the fine art of requirements triage.

The intended audience is requirements writers, analysts, project
managers, product managers, and program managers.

Al Davis is founder and president of Omni-Vista, Inc., a Colorado
corporation dedicated to helping companies avoid software project
disasters through improved product planning. He is on extended leave
of absence from the University of Colorado at Colorado Springs. He was
a member of the board of directors of Requisite, Inc., acquired by
Rational Software Corporation in 1997. He has consulted for many
corporations over the past twenty years, including Boeing, British
Telecom, Cadence Design Systems, Cigna Insurance, Federal Express,
Flight Dynamics, Fujitsu, General Electric, Great Plains Software, IBM,
Loral, MCI, Mitsubishi Electric, NEC, NTT, Rational Software, Rockwell,
Schlumberger, Sharp, Software Productivity Consortium, Storage Tek,
Sulzer Intermedics, and Sumitomo. Previously, he was a Vice President
of Engineering Services at BTG, Inc., a Virginia-based software startup
that went public in 1995. Prior to joining BTG, he was a Director of
R&D at GTE Communication Systems in Phoenix, Arizona, and Director of
the Software Technology Center at GTE Laboratories in Waltham,
Massachusetts. He has held academic positions at George Mason
University, University of Tennessee, and University of Illinois at
Champaign-Urbana. He is Editor-in-Chief Emeritus of IEEE Software
after serving as Editor-in-Chief from 1994 to 1998. He is an editor
for the Journal of Systems and Software (1987-present) and was an
editor for Communications of the ACM (1981-1991). He is the author of
Software Requirements: Objects, Functions and States and the
best-selling 201 Principles of Software Development. He is the founder
of the IEEE International Conferences of Requirements Engineering, and
served as general chair of its first conference in 1994. He has been a
fellow of the IEEE since 1994, and earned his Ph.D. in Computer Science
from the University of Illinois in 1975.

Design nearly always starts with the recognition of a problem, proceeds
with the development of opportunities, and finishes with the delivery
of a product. As designers, we must recognize _all_ of the *essential
features*, develop _just the right number_ of *expected features*, and
create, for competitive advantage (and ego), a _few_ *gee whiz*
features. We have found great benefits from including critical users
as an integral part of the entire life cycle design activity.

We will discuss, in a highly interactive manner, the means we have used
to include these users---from concept development into the business
case and continuously throughout all aspects of the requirements
elicitation and product development stages, systems design, product
delivery, and yes, even in production and proactive product
refinement. We will present a handful of heuristics that we have found
to be particularly useful in eliciting several of the many dimensions
of user needs and wishes. As an important by-product, these heuristics
make design thinking much more visible to all parties. We are provided
a much clearer picture of design responsibilities, project scope and
risk, and, most importantly, a more consistent view of user
expectations.

This workshop is intended for all professionals involved in the
development of complex computer systems. This includes executives
making funding decisions, product managers, planners, systems analysts,
requirements engineers, software developers, systems maintenance, and,
what the heck, even end users.

Donald C. Gause, is a Principal of Savile Row, LLC as well as Bartle
Professor in Systems Science in the Thomas J. Watson School of
Engineering, SUNY/Binghamton. Don Gause has worked as an engineer and
computer programmer and has managed engineering, programming and
education groups with General Motors and IBM. He has been active as a
consultant and professor for the past 32 years and served for many of
these years as an adjunct member of IBM's Systems Research Institute
(SRI). He has been a visiting scholar and has lectured at many
universities and institutes around the world, has been an associate
editor of the International Journal of Cybernetics and Systems, and has
served as a national lecturer for a number of professional societies.

Mr. Gause's consulting and research interests include the management of
innovation within large organizations, the design of user oriented
systems, and the development and analysis of systems design processes.
He has advised in the elicitation and documentation of business plans
and requirements for Internet start-ups. He has also consulted on the
development of strategic business systems and new products for many
leading firms including AT&T, Bank of America, Boeing, Booz Allen &
Hamilton, Citigroup, Coming Glass, First Chicago, Ford Motor Company,
GE, GTE, IBM, ITT, Medtronic, Microsoft, Northern Telecom, Rockwell
International, Rolls Royce, Wells Fargo, and Westinghouse.

Mr. Gause is the author (with G.M. Weinberg) of Are Your Lights On?:
How to Figure Out What the Problem REALLY Is, Dorset House, N.Y., 1990
and Exploring Requirements: Quality BEFORE Design, Dorset House, N.Y.,
1989.

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. A key to
the success of this strategy is the investment in facilities for
rapidly producing new members of the product line. This half-day
tutorial describes 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.
This in-depth tutorial will teach the participants the principles
underlying the approach and will give them a chance to perform a
practice commonality analysis guided by an experienced user of the
process.

Potential participants should have some experience in the practice or
management of software development, but no assumptions are made about
that experience.

Mark Ardis is a Member of the Technical Staff in the Software
Production Research Department at Bell Laboratories, Lucent
Technologies. Before joining Bell Labs Mark taught software
engineering courses at the University of Illinois at Urbana-Champaign,
the Wang Institute of Graduate Studies, and Carnegie Mellon University
(CMU). He was a founding member of the CMU Master of Software
Engineering (MSE) program, and helped establish several other MSE
programs at other schools through the dissemination of his courses by
videotape. Mark has collaborated with several projects at Bell Labs
to teach the commonality analysis method and to perform domain
engineering activities. Mark has given tutorials at 5 previous
International Conferences on Software Engineering.