Tutorial Program

Quality Track

QUAL1

 Monday, August 2
 9:30 - 13:00

Systematic Techniques for Inspecting Critical Software
David L. Parnas, McMaster University, Canada

Software is devilishly hard to inspect. Serious errors can hide for years. Consequently, many are hesitant to employ software in safety-critical applications and all companies are finding the cost of correcting and improving software to be an increasing burden.

This talk describes a procedure for inspecting software that consistently finds subtle errors in software that was believed to be correct. The procedure is based on four key ideas:

• All software reviewers actively use the code
• Reviewers exploit the hierarchical structure of the code rather than proceeding sequentially through the code
• Reviewers focus on small sections of code, producing precise summaries that are used when inspecting other such sections
• Reviewers proceed systematically so that no case, and no section of the program, gets overlooked

During the procedure, the inspectors produce and review precise documentation. They are able to check for complete coverage; tabular notation allows the work to proceed in small systematic steps. The procedure was originally developed and used to inspect safety-critical software in a nuclear power plant, and then improved based on that experience.

David Lorge Parnas is the NSERC/Bell Industrial Research Chair in Software Engineering in the McMaster University Faculty of Engineering's Computing and Software Department where he is Director of the Software Engineering Programme. He is also an associate member of the Department of Electrical and Computer Engineering. He has been Professor at the University of Victoria, the Technische Hochschule Darmstadt, the University of North Carolina at Chapel Hill, Carnegie Mellon University and the University of Maryland. He has also held non-academic positions advising Philips Computer Industry (Apeldoorn), the United States Naval Research Laboratory in Washington, D.C., the IBM Federal Systems Division, and the Atomic Energy Control Board of Canada.

Level: Intermediate

QUAL2

 Tuesday, August 3
 9:30 - 13:00

The Development and Verification of Safety Critical Software
George Romanski, Aonix, USA

A safety critical system controlled by software relies heavily on the properties of the software, because they affect the level of trust of the system as a whole. Absolute measures of correctness do not exist for software. We rely on verification techniques to provide an acceptable level of confidence.

Simple assembly level and programs can be verified by building up the behavior of each instruction, sequences of instructions, functions, and so on until the entire program is understood. For larger systems this is impractical. When high level languages are used in control systems, several levels of abstraction contribute to the understanding of system behavior. To verify that a program does not compromise system safety, each construct must be verified as well as the transformations between abstraction levels.

A number of verification techniques exist. Information hiding, overloading, inheritance and other techniques offered in a programming language may ease program development, but they may make verification more difficult or impossible. Use of certain concurrency constructs may simplify the real-time model and our understanding of system behavior, while other constructs may make the model non-deterministic.

The relationship between programming language constructs, verification techniques and safety certification requirements will be presented.

George Romanski is the Director of Safety Critical Software at Aonix. He has specialized in the production of software development environments for the last 29 years. The work focused on compilers, cross compilers, run-time systems and tools, primarily for embedded real time applications in several languages, but focusing on Ada over the last 19 years.

Over the last seven years George Romanski has concentrated on software tools and certification materials for safety critical applications. The results of the work have been used on avionics, railway and nuclear applications at the highest levels of criticality.

Prerequisites: at least one programming language (not one in particular), some of the simpler verification techniques.

Level: Intermediate

QUAL3

 Wednesday, August 4
 14:30 - 18:00

Managing By Contract
Bertrand Meyer, Interactive Software Engineering, USA

To deliver on its promises, object-oriented technology must be able to produce systems that are reliable (correct and robust). Only under these conditions will the other quality factors advertized for the method, in particular the increase in reusability and extendibility, yield the expected benefits for software practitioners. It is indeed possible to use object-oriented technology to produce, almost routinely, software systems that reach a degree of reliability without any equivalent in conventional methods, languages and tools. The presentation will explain how Managing by Contract will help project managers achieve this goal.

Bertrand Meyer is president of Interactive Software Engineering and a pioneer of object technology through his books, in particular "Object-Oriented Software Construction" (whose second edition published by Prentice Hall received the Software Development Jolt Product Excellence Award 1997), "Reusable Software" and "Object Success". Active in both the business and academic scenes he has directed the development of widely used O-O tools and libraries totaling hundreds of thousands of lines, and taught O-O principles and modern software engineering worldwide. He is editor of the Object Technology column of IEEE Computer, the Eiffel column in the JOOP, the Prentice Hall O-O Series, and the Addison-Wesley Eiffel in Practice Series.

Prerequisites: familiarity with the basic OO concepts.

Level: Intermediate

QUAL4

 Thursday, August 5
 9:30 - 13:00

Verification and Validation of Object-Oriented Software Systems
Kasi Periyasamy, University of Manitoba, Canada

Verification and validation processes become integral part of software systems, particularly when the software systems are large and complex. The methods for verification and validation that are currently applied to procedural software development processes are not adequate for object-oriented software development. This is because some of the distinguishing characteristics of the object-oriented paradigm such as inheritance and polymorphism require additional efforts, methods and techniques for verification and validation. In this tutorial, I first motivate the participants towards the need for verification and validation of software systems and then give a brief overview of the methods for verification and validation of procedural software systems. I will then discuss in detail some methods for verification and validation of object-oriented software systems. The discussion will include a number of simple examples for each method. The tutorial will also address the limitations of these methods and current research issues in this topic. The tutorial has been designed to be more general so that project leaders, project managers and software designers can attend this tutorial.

Kasi Periyasamy is an Associate Professor in the Department of Computer Science at the University of Manitoba, Winnipeg, Manitoba, Canada. His main area of interest is the application of formal approaches to software development. He has used many formal specification techniques for various phases in software development, mainly for requirements analysis. He has developed a real-time extension to the Object-Z specification language called Real-Time Object-Z (RTOZ), in collaboration with Dr. Alagar at Concordia University, Montreal. Dr. Periyasamy is a co-author of the book "Specification of Software Systems" published by Springer-Verlag in 1998. Dr. Periyasamy was a principal member of the X3J21 Standards Committee (accredited by ANSI) on "Formal Specification Languages: VDM-SL and Z" until 1996 and continues to be a member in correspondence.

Dr. Periyasamy has taught several undergraduate and graduate courses on formal methods and object-oriented software development, both at the University of Manitoba and at Concordia University. He has taught the course on Software Verification and Validation at the graduate level. He has given short courses to industries on object-oriented analysis and design.

Prerequisites: some knowledge on the principles of object-orientation; exposure to OO analysis and design techniques, and/or OO formal specifications will be an asset, but is not required.

Level: Intermediate

QUAL5

 Monday, August 2
 15:30 - 18:00

Advanced Programming by Contract
James C. McKim, Rensselaer at Hartford, USA

This tutorial provides a number of principles for using Programming by Contract to rigorously document class interfaces in a way that is accessible to technically-oriented software developers. With each principle an example, a justification, and advice about when it might be appropriate to violate the principle (and how to document such violations) is presented. The complexity of the principles vary. Some are simple enough that we can use them to improve the documentation of almost any class. Others are sufficiently complex and time-consuming to use that they may only be appropriate in designing class libraries. Examples will be used from ELKS, the Eiffel Library Kernel Standard to illustrate the power of the Principles.

James C. McKim is a professor of computer science at the Hartford Graduate Center and has more than 25 years experience teaching mathematics and computer science. He has authored, coauthored and reviewed a number of textbooks and articles in both areas. His research interests include object--oriented programming and design in general, and class interface specification in particular.

Language Track

LANG1

 Monday, August 2
 9:30 - 13:00

Mastering JFC 'Look and Feel' and UI Delegation
Mitchell Goldstein, Modis Inc., USA

This is an in-depth presentation on UI (user interface) delegation in Java Foundation Classes and how JFC component classes support platform-emulation and cross-platform 'look and feels'. This talk will cover: detailed analysis of the LAF and UI management classes, discussion of the standard LAFs , customizing LAFs through multiplexing and custom schemes, and a tutorial on how to design, develop, debug and deploy a custom cross-platform 'look and feel'.

Mitch Goldstein is a consultant with over fifteen years of experience in the data processing field, specializing in object-oriented and component-based development of graphical user interfaces and enterprise distributed systems. Mitch is the author of "Comprehensive JFC", an advanced technical guide to the Java™ Foundation Classes, to be published by SIGS/Cambridge University Press in the fall of 1999. Mitch is currently working with NASDAQ/AMEX to redesign their equity trading workstation in Java/JFC.

Prerequisites: intermediate experience with Java and Java Foundation Classes

Level: Intermediate/Advanced

LANG2

 Monday, August 2
 9:30 - 13:00

Quality Component Development: Making the Most of JavaBeans and Enterprise JavaBeans Features
Gilda Pour, San Jose State University, USA

Component-based software development (CBSD) is the rapidly emerging trend in the field of enterprise software engineering. CBSD delivers the promise of large-scale software reuse and has the potential to:

• Reduce significantly the cost and time-to-market of enterprise systems
• Enhance the reliability of enterprise systems
• Improve the maintainability of enterprise systems
• Enhance the quality of enterprise systems

The attendees will have the opportunity to become familiar with the key features of the leading Java-Based component technologies: JavaBeans and Enterprise JavaBeans (EJB). They will also learn how to develop quality components for client-side using JavaBeans and for server-side using EJB. Major topics include:

• Background
• Java Platform for the Enterprise (JPE)
• JavaBeans Component Model
• Enterprise JavaBeans (EJB) Component Model
• Quality Component Development Using JavaBeans and EJB
• Future of JavaBeans and Enterprise JavaBeans
• Useful Resources

Gilda Pour has over eleven years of R&D and industrial experience and seven years of academic experience in object-oriented software engineering for parallel and distributed systems. Dr. Pour’s current research areas lie in the field of object-oriented component-based enterprise application development including multi-tier Web-based enterprise application development. She has made significant contributions to several projects in the fields of distributed enterprise object computing and Internet technology while working in the R&D Laboratories of Hewlett-Packard Company and Software Engineering Research Center. She has also contributed significantly to a number of research projects funded by Rome Laboratory/Air Force and industry.

Dr. Pour is currently a professor of software and information engineering at San Jose State University. She has developed and taught several courses on component-based enterprise software engineering, component-based enterprise application development, component technologies, and distributed object technology in both industry and academia. On related topics, she has given seminars and tutorials, chaired panels, and led workshops at international conferences including TOOLS USA, TOOLS ASIA, Computer Software and Applications Conference (COMPSAC), the World Conference of the WWW, Internet, and Intranet (WebNet), Advanced Software Technology for the 21st Century, etc. She serves as the Workshop and Panel Chair for the TOOLS USA ’99 Conference and as the Tutorial Chair for the TOOLS ASIA ‘99 Conference.

Prerequisites: familiarity with the fundamental concepts and principles of OO software development, distributed object computing, and Java. Working experience with JavaBeans (or Java) would be helpful but not necessary.

Level: Intermediate

LANG3

 Monday, August 2
 15:30 - 18:00

Ada and the Objects
Benjamin Brosgol, Aonix, USA

The original Ada language, designed in the early 1980s, was object-based but not fully object-oriented; it supported encapsulation and data abstraction but not inheritance, polymorphism or dynamic binding. A language revision effort culminating in ISO standardization in 1995 has filled this gap. After summarizing Ada's main features, this tutorial explores the language's approach to Object Orientation. The presentation develops an example to motivate and illustrate the key semantic and stylistic points, compares Ada with other OO languages (C++, Eiffel, Java), and explains the rationale for major language design decisions. Topics include:

• Why Ada realizes the class concept through both a data type facility and a modularization construct, and the effects of this design decision
• Implications of explicit versus implicit "pointers" for polymorphism
• Interactions between encapsulation (visibility control) and OOP
• How Ada models multiple inheritance
• How the developer can define class-specific operations for storage management and assignment
• Why object creation presents pitfalls for effective de-centralized OO style, and how to avoid these pitfalls
• How to write applets in Ada

After attending this tutorial, the student will understand Ada's OO model, but will also see the underpinnings of OOP in a way that leads to more effective OO styles with other programming languages.

Benjamin Brosgol has over 25 years of experience in the computer software industry, with a focus on programming language design and implementation (Ada in particular), software engineering, Object-Oriented technology, Information Systems, and real-time applications. He has been continually and actively involved with Ada since its inception in the mid-1970s, as a language designer, reviewer, compiler developer, user, and educator. He was a member of the team that conducted the Ada 95 language revision, where he was responsible for designing the Information Systems support. He has been conducting Ada courses since 1982, both in the U.S. and abroad, for private industry, government, and academia. Dr. Brosgol has long been active in the Ada community and is currently the chairman of ACM's SIGAda (Special Interest Group on Ada). He is presently a senior member of the Professional Services group at Aonix.

Prerequisites: familiarity with the main concepts of OOP in a language such as C++, Eiffel or Java. No previous experience with Ada is required.

Level: Intermediate

LANG4

 Tuesday, August 3
 14:30 - 18:00

Programming with C++ Exceptions
Angelika Langer, Germany

When introduced to the language, exception handling added a whole new dimension of programming techniques to C++. Despite of its indisputable advantages, it is still rarely used. This is because exception handling can be quite harmful when used in programs that are not prepared to cope with exceptions. In ANSI C++, we cannot ignore exceptions any longer because certain language constructs, such as new expressions or dynamic_cast as well as the standard library, already raise exceptions. In this lecture we explore exception safety, i.e. what we can and have to do in order to make our programs behave nicely even in presence of exceptions. Another aspect of interest is exception safety in conjunction with template libraries such as the STL. We will see which safety guarantees the STL gives and what it requires of its users. To round up our knowledge of C++ exceptions handling we eventually take a look at some of the less widely known language features such as uncaught exceptions, terminate handlers, and exception specifications.

Angelika Langer teaches C++ related topics as a freelancer in Europe and the US. She's a recognized speaker at various international conferences, among them C++ World, OOP, TOOLS Pacific. She's a columnist for C++ Report and a member of the C++ standards committee.

Prerequisites: at least 1 year of working knowledge of C++, plus knowledge of the concept of C++ exception handling.

Level: Intermediate

LANG5

 Tuesday, August 3
 14:30 - 18:00

Behind the Beans
Michael Stal, Siemens AG, Germany

Developers are facing a very rapid evolution of new products and technologies. In addition, they have to cope with increasing customer requirements. Competitors must provide new products releases in decreasing time frames without hampering quality. Thus, the question arises how these different forces might be balanced. The right answer is: If technological evolution and requirements are changing rapidly, at least the underlying software architectures should remain stable. Architectures must be built with future changes and extensions in mind. On one hand, Multi-tier Architectures might be introduced for this purpose. This helps for a separation of concerns, but alone it is not sufficient. To design for change and evolution a component-based approach is the right choice. Components represent fundamental units of distribution and functionality. They define hooks for future change and extension. This is the reason why the Java Beans technology was introduced by JavaSoft. However, JavaBeans are a perfect solution for building desktop-centered user interfaces, but they do not help for deploying functionality on the server-side. Therefore, JavaSoft has recently provided the Enterprise JavaBeans Specification. Despite of their names, JavaBeans and Enterprise JavaBeans are different technologies addressing different tiers of multi-tier architectures. The tutorial will give an in-depth introduction of both technologies. It will also compare the technologies with the alternatives provided by Microsoft WindowsDNA.

Michael Stal is responsible for the research project Distributed Object Computing at Siemens AG. His main research areas are Object-Orientation, Distribution, Design Patterns, and Java. He is co-author of the book "Pattern-Oriented Software Architecture -A System of Patterns", Wiley & Sons, 1996. He is also editor of Java Spektrum, a German SIGS magazine on Java. Michael is member of the Object Management Group. His articles were published in magazines such as C++ Report, Objektspektrum, Java Spektrum, Object Magazine, JOOP, and i'x. He gave talks and tutorials at TOOLS '94, OOP'95, '96, '97, '98, CUC'96, '97, OOPLSA '96, '97, '98, Object Expo London '95, Object Expo New York '96, object+component forum Vienna '97, '98.

Prerequisites: familiarity with OO concepts and OO programming languages. Good knowledge in Java is required. Knowledge on other component technologies is useful, but not required.

Level: Intermediate

LANG6

 Wednesday, August 4
 9:30 - 13:00

Java, Eiffel and C++: The Language Comparison
Ian Joyner, Microsoft Research Institute, Australia

This tutorial is based on my upcoming book comparing Eiffel, Java and C++. While the object models of these languages are very similar, they are very different in the ease with which software can be built. We will examine the differences between the languages, their strengths and weaknesses in a hard-headed look. The superficial syntactic differences will be looked at, but more importantly, the semantic differences and philosophical basis of each language.

We will see how these differences apply in actually developing software, as it is not just a question of theoretical niceness, but practical application, and what this means in terms of ensuring quality in software.

Ian Joyner has been involved in object-oriented programming for almost 20 years, has developed many OO systems, notably communications programs and a music publisher in MacApp, and written OO compilers. He is also interested in programming language issues and is currently writing a book comparing Java, Eiffel and C++. He has ported EiffelS to the Macintosh, and has developed the MOTEL library. He is currently employed at Macquarie University in the Microsoft Research Institute where he is involved with project Bruce to translate Eiffel to Java, and interface the Eiffel and Java libraries. He also tutors the third year database course.

Prerequisites: experience in any one or more of these languages. However, it will also be of interest to people who are considering which OO language to adopt.

Level: Intermediate/Advanced

Technology Track

TECH1

 Wednesday, August 4
 9:30 - 13:00

Mastering the Windows Eiffel Library
Glenn Maughan, Westernport Group Pty Ltd, Australia & Raphael Simon, ISE, USA

An object-oriented approach to building Windows software requires at least three components. These are: an object-oriented language that provides proper support for object oriented concepts, an object-oriented encapsulation of the Windows API library and a set of base or kernel classes that provide all of the necessary data structures and abstractions needed to build software. The language used in this tutorial is Eiffel. Eiffel is a pure object-oriented language designed from the ground up to support the production of quality software. The API encapsulation library is the Windows Eiffel Library (WEL) providing a complete and easy way to use encapsulation of the Windows API. And finally, the base library used is the EiffelBase library providing a myriad of standard software component abstractions. These three tools provide a surprisingly powerful way of engineering quality Windows software.

This tutorial explores the use of object technology, COM, and the WEL library for building quality Windows software. The components that the WEL library provides and how to use them are discussed incrementally through the development of a small application.

COM and the Eiffel COM interface (EiffelCOM) are used to interact with existing Windows components and to componentize the developed application.

The tutorial provides a sufficient description of using object technology, COM, and the WEL library for use in constructing complete Windows applications.

Glenn Maughan has been studying object-oriented methods and development for the past 8 years. After gaining his PhD in object-oriented architecture at Monash University (Australia) he continued to develop his experience in the field. Glenn's breadth of experience includes developing and deploying both academic and industrial systems written in Eiffel, Java and C++. He is currently a Software Consultant for the Westernport Group in Australia and, in the few hours spare each week, is co-authoring a book on Windows programming in Eiffel.

Raphael Simon a graduate of ENSEIHHT in Toulouse, France, is a software engineer at Interactive Software Engineering, where he has worked on Windows object-oriented development tools, OLE, COM, and the EiffelCOM library. He consulted on various large projects in the US and UK and gave several training courses in Canada and South Africa.

Level: Intermediate

TECH2

 Wednesday, August 4
 14:30 - 18:00

Distributed Objects from a Patterns Perspective
Michael Stal, Siemens AG, Germany

Nowadays, infrastructures for Distributed Object Computing such as COM, CORBA or RMI have become common place. When building software systems with one of these technologies it is essential to understand the fundamental concepts behind them. But what are the concepts behind these infrastructures? Actually, there is no architectural description available, neither for DCOM nor for CORBA or RMI. However, only with this knowledge it is possible to build distributed systems that adhere to functional and non-functional requirements. With patterns a new method for building and also for analyzing software systems has emerged. Patterns help to get a substantial understanding of the structure and dynamics of distributed objects systems such as DCOM or CORBA. The tutorial presents a pattern system that covers many fundamental aspects of Distributed Object Computing. A web of patterns will be presented that together reveal the architecture of distributed objects infrastructures.

Michael Stal is responsible for the research project Distributed Object Computing at Siemens AG. His main research areas are Object-Orientation, Distribution, Design Patterns, and Java. He is co-author of the book "Pattern-Oriented Software Architecture -A System of Patterns", Wiley & Sons, 1996. He is also editor of Java Spektrum, a German SIGS magazine on Java. Michael is member of the Object Management Group. His articles were published in magazines such as C++ Report, Objektspektrum, Java Spektrum, Object Magazine, JOOP, and i'x.He gave talks and tutorials at TOOLS '94, OOP'95, '96, '97, '98, CUC'96, '97, OOPLSA '96, '97, '98, Object Expo London '95, Object Expo New York '96, object+component forum Vienna '97, '98.

Prerequisites: familiarity with OO concepts and OO programming languages. Basic knowledge in distribution technologies is required. Knowledge on patterns isuseful, but not required.

Level: Intermediate

TECH3

 Wednesday, August 4
 14:30 - 18:00

Building Scalable ODBMS Applications
Matt BenDaniel, Object Design, USA

Experienced application developers have concluded that an Object Database is an essential building block for OO systems that support high usage loads and gigabyte-to-terabyte-sized storage. ODBMS provide tremendous advantages compared with RBDMS, flat files or serialization, but only when the appropriate design and implementation techniques are applied. The nature and importance of these techniques can become painfully apparent during project delays due to the pitfalls that abound.

The tutorial first reviews the main aspect of ODBMS architecture and key scalability concepts. The techniques are covered with diagrams and examples. The tutorial concludes with a close look at a deployed application using these techniques.

Matt BenDaniel is Principal Consulting Engineer at Object Design, Inc. For eight years the author has provided ODBMS training, design consulting, and deployment assistance to hundreds of clients. BenDaniel has an SB from MIT in Computer Science and an SM in Management from the Sloan School at MIT.

Prerequisites: proficiency with C++ or Java and distributed applications or DBMS.

Level: Intermediate

TECH4

 Thursday, August 5
 14:30 - 18:00

Real-Time Object-Oriented Distributed Systems: RT CORBA and RMA
Antonios Broumas, Tri-Pacific Software, USA

CORBA stands for Common Object Request Broker Architecture and it is a set of middleware architectural specifications adopted by the OMG, the Object Management Group. One of the goals of the class is to enable the attendees to see independently why CORBA is the best middleware choice available and how to choose and configure the appropriate ORB that meets their needs. A long awaited natural extension to CORBA is Real-Time CORBA. The goal of RT CORBA is to support end-to-end predictability. In our tutorial we will explain what a "Schedulable Entity" actually is, what are its interfaces and how priorities are controlled and propagated in a CORBA real-time distributed object oriented computing environment.

Subsequently we will introduce the attendees to Real-Time analysis and design and in particular schedulability analysis using RMA, Rate Monotonic Analysis. The term "rate monotonic" originated as a name for the optimizing task priority assignment technique in which higher priorities are accorded to tasks that execute at higher rates. RMA is a simple, practical, mathematically sound way to ensure that all timing requirements will be met. Using RMA we are able to identify and eliminate unbounded priority inversion, and can guarantee that all hard deadlines will always be met. In addition toworst-case schedulability analysis, RMA can also show that average-case performance demands are satisfied.

After the tutorial the attendees would be able to have a global view of the development process of a Real-Time CORBA application environment based on a sound understanding of the underlying basic RMA concepts.

Antonios Broumas joined Tri-Pacific Software Inc. in 1998 as a senior consultant. He is a graduate of the Electrical Engineering School of the National Technical University of Athens, Greece. He received his M.S. in Electrical Engineering and his Ph.D. in Mathematics from The University of Texas at Austin. He has held positions in teaching, research, and software development at The University of Arizona at Tucson and at the Mathematical Sciences Research Institute at Berkeley, California, USA.

Prerequisites: a very basic acquaintance with object oriented programming premises and real-time programming issues is desirable but not necessary.

Level: Introductory

Methodology Track

METH1

 Monday, August 2
 15:30 - 18:00

System Design: Architectures and Archetypes
Stephen J. Mellor, Project Technology, USA

The challenges of developing high performance, high reliability, and high quality software systems are too much for ad hoc and informal engineering techniques that might have worked in the past on less demanding systems. New techniques for managing these growing complexities are required to meet today's time-to-market and productivity demands. This tutorial shows you how to:

• engineer the system-wide design to meet performance constraints;
• identify the characteristics of the problem that determine the system design;
• model the system-wide design--the software architecture;
• build archetypes that generate efficient code.

This approach produces a number of beneficial results:

• productivity: reuse is built in to the software architecture;
• error reduction: archetypes limit coding errors;
• time-to-market;
• open code generation reduces project schedules.

The tutorial will include a number of pencil and paper exercises that illustrate the concepts.

Stephen J. Mellor is best known for his contribution to the development of Object-Oriented Analysis and the Shlaer-Mellor Method. He is currently Senior Vice President of Project Technology, Inc., where he serves as co-researcher, with Sally Shlaer, for Project Technology's extensions and applications of the Shlaer-Mellor Method. Mr. Mellor and Ms. Shlaer are currently working on their third book: Shlaer-Mellor Method: Recursive Design. Mr. Mellor is also a member of the editorial board for IEEE Software.

Level: Intermediate

METH2

 Monday, August 2
 15:30 - 18:00

A Short Use Case Writing Workshop
Alistair Cockburn, Humans & Technology, USA

A use case is a collector for scenarios that describe an actor interacting with a system in pursuit of a goal. The workshop starts from this definition, showing how use cases can be written, cross-connected and managed. You will work with others around you, attempting to list use cases for a system, write a main scenario, and uncover failure scenarios in an impossibly short time frame. Expect to encounter differences in writing styles and to discover that use cases are much trickier to write than they seem. Learn the degrees of variation that still permit use cases to be effective.

Alistair Cockburn, special advisor to the Central Bank of Norway for object technology and software project management, was the OO methodology designer for the IBM Consulting Group before founding Humans and Technology in 1994. His book, "Surviving OO Projects", was published in 1998. He is an expert on use cases, object-oriented design, project management, and software methodologies. He has been the technical design coach and process consultant on projects ranging in size from 3 to 90 people. Materials that support Alistair's workshops can be found at http://members.aol.com/acockburn.

Level: Introductory

METH3

 Tuesday, August 3
 9:30 - 13:00

Modularization Revisited: Aspects in the Design and Evolution of Software Systems
Cristina Videira Lopes, Xerox Research Center, USA

Objects have been a great success. They have improved software development by allowing us to cleanly encapsulate units of functionality of various scales - from simple data structures to GUI tools to network servers - inside of well-defined classes.

But objects don't seem to help as much in dealing with systemic concerns such as synchronization, multi-object protocols, resource sharing, distribution, memory management, replication and the like. Rather than staying well localized within a class, these concerns tend to cross-cut the system's class and module structure. Much of the complexity and brittleness in existing systems appears to stem from the way in which the implementation of these kinds of concerns ends up being intertwined throughout the code.

Aspect-oriented programming is a new technique that has been proposed specifically to address this problem. Like objects, aspects are intended to be used in both design and implementation. During design, the concept of aspect facilitates thinking about cross-cutting concerns as well-defined entities. During implementation, aspect-oriented programming languages - namely AspectJ™ - make it possible to program directly in terms of design aspects.

This tutorial shows how to design and program with aspects and how aspects can be used to improve separation of concerns in complex software systems. Particular attention will be given to how AspectJ can support the implementation of common OO design patterns.

Cristina Videira Lopes is a research scientist at the Xerox Palo Alto Research Center. Her research interests are in software engineering and programming languages. She has been developing aspect-oriented programming languages, in particular for distributed applications. She has co-organized several workshops in several conferences, namely the AOP workshops at ECOOP, and she has presented a number of tutorials at ECOOP and OOPSLA that got excellent evaluations. She has published papers in ECOOP and ICSE, and she is a member of the Program Committee for ECOOP'99.

Prerequisites: object-oriented programming experience, and should be able to read Java syntax.

Level: Intermediate

METH4

 Tuesday, August 3
 14:30 - 18:00

Advanced Visual Modelling: Beyond UML
Stuart Kent, University of Kent, UK; Joseph Gil, Technion, Israel; and John Howse, University of Brighton, UK

With the adoption of UML by the OMG and industry as the standard visual modelling notation, it is interesting to wonder what will come next in this field? This tutorial presents a vision for visual modelling 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 modeller of the future. Highlights include:

• a crash course in UML, its weaknesses and strengths
• a rich visual constraint language (based on Venn diagrams), and an insight into subtle issues that arise when defining a visual language
• a series of 3D notations for providing rich visualisations of dynamic behaviour
• a vision for visual modelling tools of the future.

Stuart Kent is a Senior Lecturer in Computing at University of Kent, UK, and consultant and trainer to industry on both sides of the Atlantic. Research active in the areas of visual modelling, OOD and CBD. Dr. Kent has been on the programme committee for various workshops and conferences including UML ’98/9, TOOLS USA ’98/9 & EDOC ’99.

Joseph (Yossi) Gil is Assistant Professor at Technion Israel. He is widely published in many journals and conferences on a broad spectrum of topics, including both the theory and practice of Computer Science. He recently spent a year with IBM Research, New York. Dr. Gil was Chair of TOOLS USA ’98 and on the programme committees for numerous conferences including past & present OOPSLA’s and ECOOP’s. He is an experienced university teacher and trainer to industry.

John Howse is Principal Lecturer in Computing and Mathematics at University of Brighton, UK. His research focus is in the areas of semantics for OO and visual modelling languages, and, more recently, in diagrammatic reasoning. Dr Howse has many years experience in teaching.

Prerequisites: understanding of OO concepts will be expected, some sight of UML or similar notations would be beneficial, though not essential.

Level: Advanced

METH5

 Wednesday, August 4
 9:30 - 13:00

Advanced OO Modelling: Metamodels and Notations for the Next Millenium
Brian Henderson-Sellers, University of Technology, Sydney, Australia

Building an object-oriented model requires knowledge of process and techniques. Representing the model itself requires the use of a notation underpinned by a rigorous definition. Today this underpinning usually starts with a metamodel. Together, the metamodel and the notation are known as a "modelling language". Two modelling languages are described, discussed and compared: OML (the OPEN Modelling Language) and UML (the Unified Modeling Language). Advanced use of both languages is described particularly for concepts such as roles, for stereotypes and for aggregations, associations and other relationships.

Brian Henderson-Sellers is Director of the Centre for Object Technology Applications and Research and Professor of Information Systems at University of Technology, Sydney (UTS). He is author of eight books on object technology and is well-known for his work in OO methodologies (MOSES, COMMA and OPEN) and in OO metrics.

Brian is also Regional Editor of Object-Oriented Systems, a member of the editorial board of Object Magazine/Component Strategies and Object Expert for many years, Founder of the Object-Oriented Special Interest Group of the Australian Computer Society (NSW Branch) and Chairman of the Computerworld Object Developers' Awards committee for ObjectWorld 94 and 95 (Sydney). He is a frequent, invited speaker at international OT conferences.

Prerequisites: fully conversant with basic OO terminology and the need for a good metamodel and notation within a full lifecycle process methodology. Experience with OO methodologies advantageous.

Level: Intermediate/Advanced

METH6

 Thursday, August 5
 9:30 - 13:00

Analysis by Contract: An Introduction to Precise OO Modeling with UML and OCL
Richard Mitchell, University of Brighton, UK

It is easy to be abstract (draw bubbles). It is easy to be precise (write code). It is harder to be precise whilst remaining abstract. The tutorial aims to lay a firm foundation for being both abstract and precise, by showing how the principles of design by contract can be applied to analysis-level models.

At the heart of the UML are a number of visual modeling notations for describing classes, states, and so on. The UML also contains an Object Constraint Language, OCL, for adding precision to models. OCL can be used to add preconditions, postconditions and invariants to classes or types, allowing the precision of design by contract to be applied at any level of abstraction.

The precision that this affords will be increasingly important as the software industry moves further towards component-based development.

The tutorial will introduce the key features of OCL. By means of a small case study in object-oriented analysis, it will then show how OCL can be used to add precision to analysis-level models.

The case study will emphasise:

• why types are a suitable analysis-level abstraction
• how type models can provide a vocabulary for modeling
• how type models can be improved with invariants
• how state modeling can support analysis-level modeling
• how state models and type models can be cross-checked
• how behavior can be expressed using preconditions and postconditions.

Richard Mitchell is Professor of Computing at the University of Brighton, UK, where he has been teaching and researching object technology since the 1980s.

His research addresses the use of contracts at all levels of software development. He is a member of the "Amsterdam group", a group of six experts on OCL, including its designers Jos Warmer and Anneke Kleppe. The group is formulating proposed revisions to OCL and UML, to be presented to the OMG.

Richard is a qualified instructor for Catalysis, an advanced methodology that embodies the principles of design by contract at all levels of modeling, and is targeted at component-based development. He has taught Catalysis many times in Europe, the USA and Australia.

Richard is working with Jim McKim on a book about design by contract. He is a member of the recently-formed Trusted Components project, and he is Chair of the Programme Committee for TOOLS Europe 2000.

Prerequisites: some knowledge of OO. Knowledge of UML and OCL are not required.

Level: Beginner/Intermediate

Experience Track

EXP1

 Monday, August 2
 9:30 - 13:00

Design of Commercial Object-Oriented Applications - The Patterns
Frieder Monninger, Object Tools GmbH, Germany

The tutorial describes the techniques used to develop a typical commercial application (just like a thousand others) - a multiuser order processing and production control package for a medium-size company, based on a relational database, with a large number of Windows clients.

The main objective was not just building this particular application but designing strategies to produce this type of application in a general way using a "object oriented cookbook". So the most important result is a collection of patterns especially targeted at this type of application, together with the associated generators; a "Toolkit for generating a business application".

Using such a cookbook it is possible to design and generate "everyday" commercial applications very fast - but still produce very general, maintainable and extendable software.

The tutorial will point out not only the final recipe but also the way it was found and the dangerous pitfalls to avoid. It will help the participants to see a familiar activity in a new light.

Frieder Monninger has 25 years experience with object oriented programming, and has presented many seminars related to OO. During the last few years he has been working on object oriented rapid prototyping. He is co-author of the Visual Eiffel environment.

Prerequisites: background in commercial programming and object oriented design.

Level: Introductory

EXP2

 Tuesday, August 3
 9:30 - 13:00

Octopus/UML: An Object-Oriented Method Used in Industry
Rallis Farfarakis, Nokia Research Center, Finland

This tutorial will present the Octopus/UML method, which addresses the specific needs of software development projects for embedded real-time systems, for example, how to deal with the events issued by the external world. Moreover, the method is object-oriented because adopting object-oriented technology can help in the software development of real-time systems in a way that more naturally maps to the inherent nature of the systems being built, while providing benefits similar to those already well known and widely reported for the development of other branches of software, such as ease of maintenance and reuse.

Rallis Farfarakis works as a research engineer at Nokia Research Center. His present responsibilities include the education and promotion of object technology within Nokia. He is currently involved in projects with Nokia Telecommunications such as Base Station software development. He has also participated in projects with Rolls Royce Aerospace and Nokia Mobile Phones. His research interests include software engineering environments, object-oriented modelling and object-oriented development of telecommunication systems. He holds an M.Phil. in Software Engineering.

Prerequisites: knowledge of OO and UML.

Level: Intermediate

Management Track

MGMT1

 Tuesday, August 3
 9:30 - 13:00

Introduction to the OPEN Method with UML
Brian Henderson-Sellers, University of Technology, Sydney, Australia

OPEN is the premier third-generation, process-focussed, public domain OO methodology. It is documented in a number of professional-level texts. In this tutorial, a beginner's level presentation, OPEN is introduced through a number of case studies using UML as the notation.

Brian Henderson-Sellers is Director of the Centre for Object Technology Applications and Research and Professor of Information Systems at University of Technology, Sydney (UTS). He is author of eight books on object technology and is well-known for his work in OO methodologies (MOSES, COMMA and OPEN) and in OO metrics.

Brian is also Regional Editor of Object-Oriented Systems, a member of the editorial board of Object Magazine/Component Strategies and Object Expert for many years, Founder of the Object-Oriented Special Interest Group of the Australian Computer Society (NSW Branch) and Chairman of the Computerworld Object Developers' Awards committee for ObjectWorld 94 and 95 (Sydney). He is a frequent, invited speaker at international OT conferences.

Prerequisites: knowledge of OO concepts will be beneficial; no knowledge of methodologies or modelling is required.

Level: Introductory

MGMT3

 Thursday, August 5
 14:30 - 18:00

Software Development "in the Zone"
Todd Lauinger, Reliastar Inc., USA

The purpose of this presentation is to have the participants of the tutorial understand common patterns of project management mistakes. Such mistakes directly cause late, over budget, poor quality software to be produced. Participants will then learn a new approach to developing software which keeps their teams on target. As long as the team operates under the new paradigm, the team is very productive and stays in "the software development zone."

The zone approach addresses risk in all activities of software development. Risk management done in this manner is one of three critical success factors that serves to keep your software staff "in the zone." The two other factors will be discussed in the presentation.

After understanding all three of the critical zone factors, participants of the presentation will have an opportunity to practice zone management on a sample requirements specification.

Todd Lauinger is an Application Consultant at Reliastart, and a published author and experienced teacher, mentor, and software architect. Todd presented a tutorial titled "Resolutions of an Object Designer" at the TOOLS USA '98 Conference in Santa Barbara. He is scheduled to give the same talk at the Smalltalk Solutions '99 Conference in New York. You may also read a new article of his in the Java Report titled "Object-Oriented Software Development in Java?," to be published in the February 1999 issue of the magazine.

Prerequisites: full lifecycle software development experience, either as a developer or a manager.

Level: Intermediate

MGMT4

 Thursday, August 5
 14:30 - 18:00

Creating Social Agents with Reusable Components: A Practitioner's Guide
Dana Moore, AT&T Labs., USA

This tutorial is aimed at practitioner-level developers and is motivated by a desire to share with other developers the potential techniques, available tools and resources, and issues of interest augmenting the desktop with software agents.

The tutorial will focus on integrating technologies for reuse, such as COM, Java, WFC, and XML to design, create, and deploy social interface agents. It covers underlying concepts (animation, character creation, speech recognition, text-to-speech) application design issues (interactions, turn taking, interruption, persistence, levels of confidence) and programming issues (IDEs , commercial agent resources, and COM integration).

The tutorial will demonstrate integration of software agents into MS Office applications, Web pages, and on the desktop. The session is primarily a ‘hands-on’ discussion, and presents 1) a conceptual framework and detailed design discussions for agent applications, and 2) an interactive demonstration using a standard IDE and other off-the-shelf resources to create the speech-enabled, animated social agents.

Dana Moore is a senior researcher, designer and software developer specializing in agent-based system. He holds a degree in engineering and a graduate degree in technology management, both from the University of Maryland, College Park and has written numerous articles on topics ranging from active object data bases to self-managed work teams. He is one of the architects of Autopilot, an agent-based system for complex workflows. Dana is a founding member of the Agent Society and sits on its Board, currently as the AT&T representative.

Prerequisites: some programming experience would be helpful, either in Java, C, C++, Windows development.

Level: Intermediate

UML Demo

DEMO

 Thursday, August 5
 9:30 - 13:00

Features of UML Tools
Tony Wasserman, Software Methods and Tools, USA

Effective use of the UML notation requires automated support to make certain that UML models are complete and consistent. Automated support for UML ranges from simple drawing tools to sophisticated multiuser environments that provide code and document generation, as well as aids to project management. This tutorial surveys important requirements for UML development tools, including:

• Support for the modeling process
• Support for the UML language (syntax and semantics)
• Tool usability
• Code, schema, and document generation
• Customizability and adaptability
• Scalability for large models
• Multi-user support
• Life cycle support

The tutorial is accompanied by live demonstrations of several UML products as a way to illustrate some of the characteristics of various tools. These UML products cover the range of available products in price, scalability, and target market.

Anthony I. Wasserman is Principal of Software Methods & Tools, which offers consulting services on software development. He was previously Founder and Chairman of IDE, which built the Software through Pictures modeling environment. Prior to that, Dr. Wasserman was a University of California professor, and made numerous contributions to software engineering research. He is one of a handful of people to be elected as a Fellow of both ACM and IEEE.