Chair:
Linda Northrop, Software Engineering Institute
OOPSLA conferences are famous for their high quality tutorials on a range of exciting object technology topics. The OOPSLA '98 Tutorial Committee continues this tradition by offering a record 67 tutorials chosen from more than 120 proposals. The complete tutorial program covers a broad spectrum of topics selected to accommodate multiple skill levels, and to appeal to the interests of a wide range of participants, including practitioners, managers, and researchers. The tutorials are loosely categorized below for ease of selection. An * denotes a tutorial at an introductory level. Conference attendees typically choose one or more tutorials on selected topics to enhance their OOPSLA learning experience. An attendee interested in pursuing a particular aspect of object technology in depth may wish to attend a set of related tutorials described as a "thread."
To help interested participants choose which sessions to attend, the tutorials have been grouped into the following broad-based categories: Object Foundations; Java; Language; Models, Methods, Object-Oriented Analysis and Design Techniques; Architecture and Application Development Issues; Distributed Object Technology; Patterns; New Frontiers and Advanced Topics; Management Issues; and Education.
Tutorials in this category focus on topics fundamental to object technology. These tutorials are introductory in nature and are intended for those who are new to object technology or to a particular area within the technology. Other tutorials at an introductory level are found within their specific categories.
Tutorial 4*: Concepts of Object-Oriented Programming, a favorite at past OOPSLAs and upgraded for OOPSLA '98, provides an overview of object technology.
Tutorial 37*: Creating a Paradigmatic Shift into the Object-Oriented Perspective explains to newcomers the difference between the structured approach to software development and the object-oriented approach.
Tutorial 51*: Introduction to Visual Modeling and the UML introduces both visual modeling and the Unified Modeling Language.
Java's current popularity motivated a specific Java category. The Java tutorials investigate Java support for concurrency, distributed computing, component-based development, as well as how to transition from C++ to Java, and the Java/UML connection.
Tutorial 15, 15T: Introduction to Concurrent Object-Oriented Programming in Java provides a comprehensive treatment of the concurrency support provided by the Java language and core classes as well as insight into some threading issues within the Java libraries.
Tutorial 16: An Introduction to the Java Foundation Classes (JFC) provides an introduction to the major components provided by the Java Foundation Class toolkit in the context of the systematic design and development of artifacts that have a Graphical User Interface (GUI).
Tutorial 25: From C++ to Advanced Java in 1/2 day will enable developers to make an effective transition from C++ to Java.
Tutorial 26: Distributed Java Applications introduces, classifies, and compares different communication mechanisms applicable for building distributed systems using Java.
Tutorial 39: Designing Concurrent Object-Oriented Programs in Java looks at more advanced issues in designing concurrent applications using Java.
Tutorial 40: Java from UML teaches participants to construct succinct but meaningful UML descriptions of Java components.
Tutorial 52, 52T: Java Beans: Specifications, Design and Test describes an approach to the precise and systematic specification of a Java Bean.
Tutorial 53: A Practical Guide to Java on the Server explores the practical use of Java on the server.
The tutorials in this category focus on programming in specific languages other than Java, on better utilization of OO languages, and on the comparison of OO languages. Smalltalk, C++, Eiffel, Delphi, and scripting languages are addressed. Java tutorials are categorized separately above.
Tutorial 31: Model-View-Controller: Concepts and Implementations provides an in-depth coverage of the model-view-controller design pattern, its variants, and its implementation in Smalltalk, Java, and Delphi.
Tutorial 30, 30W: Scripting: Higher-Level Programming for Component-Based Systems presents an overview of scripting, scripting languages, scripting paradigms, and demonstrates the use of scripting languages in component-based development.
Tutorial 32: Java, Eiffel and C++: the Language Comparison explores the differences and similarities among Java, Eiffel, and C++.
Tutorial 34: Efficient Smalltalk Programming gives Smalltalk developers the skills and confidence necessary to directly address Smalltalk performance concerns.
Tutorial 49: Secrets of the Envy Masters provides a tour of the internals of ENVY, the team programming tool for Smalltalk.
Tutorial 62: The Standard C++ Library thoroughly describes the C++ library as it is introduced in the ISO/ANSI C++ standard.
Tutorials in this category have long been a popular OOPSLA offering. We divide them into three sub-groups: survey and comparisons, specific methods, and general analysis and design techniques.
Tutorial 10*, 10R*: Techniques for Object-Oriented Analysis and Design gives a guided tour through the highlights of object-oriented analysis and design methods, pointing out the common and some less known but valuable techniques.
These tutorials describe in detail successful analysis and design methods, or the application of specific methods to real-world problems.
Tutorial 1: The Rational Unified Process
Tutorial 2*: Practical Use Case Modeling
Tutorial 9, 9W: Responsibility-Driven Analysis
Tutorial 11, 11T: Exploring the Unified Modeling Language by Example
Tutorial 21, 21R: Responsibility-Driven Design
Tutorial 22: Mapping an Object-Oriented Design to an Object-Oriented Database
Tutorial 43, 43W: Objectory: The Unified Process
Tutorial 44: Catalysis: Systematic Components, Framework and Patterns with UML
Tutorial 45*: Business Modeling Using the Unified Modeling Language
Tutorial 51*: Introduction to Visual Modeling and the UML
Tutorial 57: Business Engineering Using UML: The Object Advantage at Age Four
Tutorial 59: A Third Generation OO Methodology - Advanced Tasks and Techniques
Tutorial 23: Advanced Object-Oriented Concepts builds on fundamental analysis and design approaches and addresses advanced topics.
Tutorial 58: Designing A Light Methodology provides valuable insights into the fabric of a methodology and shows how to select, tailor, or design an OO methodology appropriate to a specific organization or project.
The tutorials in this category examine software architecture, architectural and application development issues including framework development, systematic reuse, GUI design, fault tolerance, and testing techniques for object-oriented projects.
Tutorial 3*: Lo-Fi Design Strategies for Creating Highly Usable Object-Oriented User Interfaces teaches how to design highly usable object-oriented user interfaces using the latest in lo-fi prototyping techniques.
Tutorial 12, 12W: Testing Object-Oriented Components presents both techniques and a process for testing the individual components built as part of a project that uses OO techniques.
Tutorial 13: Modeling Component Architectures in Catalysis shows how to use modeling techniques to define a "component kit architecture."
Tutorial 14: Architecture for a Suite of Applications: Reuse for Business Success presents the importance of architecting in the development of a family of systems as well as the architectural constructs that are successfully being employed in the development of today's systems.
Tutorial 24, 24R: Testing Object-Oriented Systems presents techniques and a process for testing a software application built as part of a project that uses OO techniques.
Tutorial 35, 35W: Software Architecture and the UML examines what software architecture is and what it is not, and presents a model for architectural representation using the UML.
Tutorial 38: Object Orientation and Fault Tolerant Systems presents the role and the use of object-oriented concepts in the design and in the implementation of fault tolerant systems.
Tutorial 61: Introduction to OO Framework Development teaches the fundamental concepts involved in frameworks as well as how to construct a framework.
Tutorial 66T: Testing Distributed Object Systems presents techniques and a process for testing OO components built to be distributed across multiple processes.
Distributed computing continues to be of interest to object technologists. The tutorials in this category range from an introduction to distributed object technology to ways to tune CORBA.
Tutorial 6, 6R: OMG's CORBA and Object Management Architecture provides a thorough investigation of CORBA, OMA, and ORBs.
Tutorial 17*, 17T*: Introduction to Distributed Computing Using Objects teaches the basic ideas and paradigms of distributed object computing.
Tutorial 46: Transparency in Distributed Object Systems: What, Why and How explains the basic mechanisms used to implement transparency and how to take advantage of them.
Tutorial 60: 101 Ways to Cook CORBA presents an overview of the different aspects consider when tuning CORBA to a specific application.
Patterns have taken the object community by storm. Responding to their popularity, OOPSLA '98 patterns tutorials cover a palette of expertise levels and application areas. There are several tutorials at the introductory level including a special one-day pattern writing tutorial followed by a pattern writing workshop. There are also tutorials for design patterns and analysis patterns, for patterns in communication applications, distributed systems, business modeling, and for anti-patterns.
Tutorial 5*: Pattern Writing teaches pattern-writing skills in the context of the broader goals and values of the pattern community. The Pattern Writers' Workshop (workshop 23) is a recommended follow-on.
Tutorial 18: An Introduction to Design Patterns describes a set of fundamental design patterns and, through a design scenario, demonstrates how to build reusable OO software with them.
Tutorial 27: Parallel Performance Patterns presents a family of design patterns that improve software performance with an emphasis on parallel performance.
Tutorial 33: Analysis Patterns introduces the concept of analysis patterns as well as some concrete examples that are useful in a number of domains.
Tutorial 36: Using Design Patterns and Frameworks to Develop Object-Oriented Communication Software illustrates by example how to significantly simplify and enhance the development of communication software that effectively utilizes concurrency and distribution.
Tutorial 47: Patterns for Making your Business Objects Persistent in a Relational Database World presents a set of patterns and a language-independent object model that can be used for mapping business objects to a relational database.
Tutorial 48: Designing with Patterns shows how to leverage patterns in the software design process.
Tutorial 54: Patterns for Distributed And Agent-Based Systems presents a collection of practical patterns to develop distributed software architectures.
Tutorial 64*: Introduction to AntiPatterns presents the concept of antipatterns and multiple antipattern examples and case studies.
Tutorial 67R: Patterns at Work shows how patterns drive the process of building high-quality software and that applying patterns is not a mechanical task that automatically leads to success.
These tutorials examine very specific areas of object technology at an advanced level and probe the new frontiers object technologists are pursuing.
Tutorial 7: Efficient Implementation of Object-Oriented Programming Languages presents the issues and state-of-the-art techniques for implementing object-oriented languages efficiently.
Tutorial 8: Using Subject-Oriented Programming to Overcome Common Problems in Object-Oriented Software Development and Evolution investigates subject-oriented programming as a practical approach to object-oriented programming-in-the-large.
Tutorial 41: Beyond Objects: Unleashing the Power of Adaptive Agents explores a future in which objects come alive as active and mobile agents inside information networks of an enterprise.
Tutorial 50: Typing in Object-Oriented Languages: Achieving Expressiveness and Safety illustrates how strong static type systems can enhance the expressiveness of a language as well as enforce safety.
Tutorial 63: Putting Metaclasses to Work demonstrates how metaclasses can be used to increase productivity and reusability in object-oriented programming, and describes facilities required for composable metaclasses.
Tutorial 65: Aspect-Oriented Programming with AspectJ introduces the concepts of aspect-oriented programming.
Tutorials in this category are targeted at managers and corporate leaders to help them better understand the impact of object technology and to provide them specific approaches for both the transition to and the management of object technology projects.
Tutorial 19*: Surviving Your OO Project provides managerial support for successfully completing a first or a first large project using object technology.
Tutorial 28: Object Transition Management presents a methodology for developing a transition management strategy to the use of object technology.
Tutorial 42: Advanced Object Project Management explores ways to successfully manage to obtain the most benefits from object-oriented technology.
Tutorial 55*: The Manager's Role in a Successful Transition to Object-Orientation explores how managers can assure that their group makes a successful transition to using object-oriented technologies.
Tutorial 56: Structuring Object-Oriented Software Development Project Teams in Support of System Architectures focuses on the organizational structure of teams involved in object-oriented software development.
There are two tutorials that focus on teaching object technology.
Tutorial 20: GOF Pursuit - Learning Patterns by Playing focuses on learning design patterns and teaching them to others.
Tutorial 29: Using a Multi-Term Project to Teach OO Programming and Design discusses the positives and negatives of a multi-term project OO course and shares experiences on OO group projects.
Ken Bauer, Safeware Engineering Corp.
Mamdouh Ibrahim,
Electronic Data Systems
Gus Lopez, Verio Northwest
Linda Northrop, Software Engineering Institute
| Tutorials by Title |
Tutorials
by Category |
Tutorials by Thread |
Full
Description of all Tutorials |
Tutorial Availability |
Last edited 31 August 1998 10:54:54