Sunday, 26 October
Monday, 27 October
Tuesday, 28 October
Wednesday, 29 October
This tutorial defines and teaches the basic object-oriented concepts, illustrates their advantages, and introduces the components and features of object-oriented programming languages and development environments. The tutorial enables an attendee to make an informed decision about what language/environment will best serve his/her software development needs.
The first part of the tutorial discusses in detail all object-oriented concepts and uses UML and Java to illustrate them. The focus will be on a precise, non-confusing definition of the core concepts and terminology. Basic object-oriented concepts, such as object, instance, class, interface, attribute, service, message passing, hierarchy, inheritance, polymorphism, late binding, memory management, access specification and packaging, will be presented.
The second part of the tutorial compares the major object-oriented programming languages: C++, Java, C#, and others. The comparison is done with a double focus: (1) how does the language support and enforce the concepts, and (2) how does the language help software development? A small case study program, solved in all the languages, will be presented to answer these questions. Whether and how each language supports advanced concepts, like multiple and repeated inheritance, genericity, interfaces, is discussed in detail.
This tutorial is targeted towards software professionals who are interested in learning the fundamental concepts and advantages of object-oriented programming and how to apply them in a modern software development environment. No previous knowledge of object-oriented concepts is assumed. The attendees should have a fundamental background in computer science and/or computer programming.
Raimund K. Ege is an Associate Professor of Computer Science at the Florida International University, Miami. He is author of several books on object oriented concepts, including a chapter on the Object-Oriented Language Paradigm in the upcoming "Computer Science and Engineering Handbook" edited by Allen B. Tucker (CRC Press, 2003). He is an active researcher in the area of object-oriented concepts, and their application to programming, user interfaces, databases, simulation and software engineering. He has presented numerous successful and highly rated tutorials at major conferences (OOPSLA, ECOOP, TOOLS).
Today, domain-specific visual languages provide a viable solution to raise the level of abstraction beyond coding. Industrial experience has shown productivity improvements of 5-10 times. We believe that it is time to start talking about Domain-Specific Modeling as the new paradigm for developing applications and product families for a given domain/platform.
In domain-specific modeling the models are constructed using concepts that represent things in the application domain, not concepts of a given programming language. The modeling language follows the domain abstractions and semantics, allowing developers to perceive themselves as working directly with domain concepts. Together with generators and components DSM can automate a large portion of software production.
Industry/academic experience reports
While OO has become ubiquitously employed for design, implementation, and even conceptualization, many practitioners recognize the concomitant need for other programming paradigms according to problem domain. Nevertheless, the choice of a programming paradigm is strongly influenced by the supporting programming language facilities. In turn, choice of programming language is usually a practical matter: one cannot generally afford to use a language not in the mainstream. We seek answers to the question of how to address the need for other programming paradigms in the general context of OO languages.
Can OO programming languages effectively support other programming paradigms? The tentative answer seems to be affirmative, at least for some paradigms; for example, significant progress has been made for the case of (higher order, polymorphic) functional programming in C++.
This workshop seeks to bring together practitioners and researchers in this emerging field to 'compare notes' on their work--describe existing, developing, or proposed techniques, idioms, methodologies, language extensions, or software for expressing non-OO paradigms in OO languages and the .NET framework; or theoretical work supporting or defining the same. Work-in-progress reports are welcomed.
Keywords: multiparadigm programming, object-oriented languages
In software development projects it is necessary to find a common understanding of the architectural concept model. Concepts might be, for example, Business Objects, Services, or Forms. They provide the common "language" of the architects. To implement an adequate system architecture it is crucial for any software developer to share this "language."
Usually a class structure alone cannot provide enough strength of expression to represent a concept model, since concepts might include several classes and even other software artifacts.
We are looking for a structure above the class level, which comprises and communicates the additional semantics of the concept model. We will discuss ontologies to describe this structure.
Ideally, the concepts themselves, their relations, hierarchies, and extension points, i.e. the ontology, should be detectable on source code level. We will examine modularization concepts and component models for implementation.
Papers can range from academic research to practical experiences.
Keywords: Ontology, Modularization, Architecture
AspectJ is a seamless, aspect-oriented extension to Java. It can be used to cleanly modularize the crosscutting structure of concerns such as exception handling, multi-object protocols, synchronization, performance optimizations, and resource sharing.
When implemented in a non-aspect-oriented fashion, the code for these concerns typically becomes spread out across the program. AspectJ controls such code-tangling and makes the underlying concerns more apparent, making programs easier to develop and maintain.
This tutorial will introduce Aspect-oriented programming and show how to use AspectJ to implement crosscutting concerns in a concise, modular way. We will also demonstrate and use AspectJ's integration with IDEs such as JBuilder, NetBeans, Emacs, and Eclipse, in addition to the core AspectJ tools.
AspectJ is freely available at http://eclipse.org/aspectj.
Prerequisites: Attendees should have experience doing object-oriented design and implementation, and should be able to read and write Java code. No prior experience with aspect-oriented programming or AspectJ is required.
Lecture and demonstration
Erik Hilsdale is a researcher at the Palo Alto Research Center. As a member of the AspectJ team, he concentrated on language design, pedagogy and compiler implementation. He has written several conference and workshop publications in programming languages. He is an experienced and energetic instructor in programming languages and has much background in AspectJ.
Jim Hugunin is a researcher at the Palo Alto Research Center. He built the first Java-based AspectJ compiler and led the subsequent implementation work up to a 1.1 release of the compiler and core tools. He also played a major role in the design of the AspectJ language. Prior to joining the AspectJ team he designed and implemented JPython/Jython, a widely used implementation of the Python language for the Java platform.
As more and more applications entail interaction among distributed collections of software components, it is becoming increasingly difficult to discern the boundaries between "application", "middleware", "client", and "server". There is an increasing demand for building internet-scale distributed applications, which have the following key characteristics: (a) lack of a single organizational "locus of control" for application development, (b) heterogeneity -- use of a wide variety of languages and systems for each application component, and (c) greater likelihood of system or network failure than in distributed applications interconnected over a local area network.
Despite work on various "infrastructure" standards for Web Services (e.g., SOAP), until recently, there has been little work on programming models directly supporting internet-scale distributed applications. However, in late 2002, the Business Process Execution Language for Web Services standard ("BPEL4WS", or "BPEL"), jointly developed by IBM, Microsoft, and BEA, was released. The name is somewhat misleading -- BPEL is more than a business process specification. It is essentially a high-level programming language, one which addresses some, but not all, of the issues relevant to developing internet-scale distributed applications.
This tutorial will first discuss general issues that arise in building internet-scale applications. Next, we will give a detailed overview of BPEL with examples, showing how BPEL addresses many of these issues. The overview will cover processes, service links activities, containers, scopes, fault handlers, and exception handlers. Finally, we will cover a number of other technologies and standards related to programming internet-scale distributed applications, and discuss their relationship to BPEL.
Prerequisites: Basic knowledge of object-oriented languages, web services, and parallel and distributed computing.
Dr. Vivek Sarkar is Senior Manager of the Programming Technologies department at the IBM T. J. Watson Research Center. His research interests are in the areas of static and dynamic program analyses and their applications to optimization, parallelization, and programming tools. The projects under way in his department include component verification (Canvas), analysis and optimization of web service and database applications (DOMO), refactoring analysis and transformation (Gnosis), adaptive optimization and memory wall (Jikes RVM), data model extraction from legacy applications (Mastery), and dynamic analysis and datarace detection (Shrike). Vivek obtained his Ph.D. from Stanford University in 1987, and has been a member of the IBM Academy of Technology since 1995.
John Field is a Research Staff Member and manager of the Advanced Programming Tools group at IBM's T.J. Watson Research Center. His research interests include static analysis and verification of programs, tools for program understanding and transformation, program slicing, program semantics and logics, and programming models for distributed systems. In addition to publishing his work in a wide variety of conferences and journals, he has contributed to the development of several IBM products. He received a Ph.D. from Cornell University in 1991.
This tutorial will provide involved hands-on programming exercises that both use some of AspectJ's advanced features, and feature AspectJ used in advanced contexts. We will show how AspectJ can be used to solve problems in instrumentation (including logging), testing, quality management, and feature management. In addition, advanced parts of the AspectJ design and implementation will be introduced, along with discussions of possible future features. Exercises will use the core AspectJ tools and IDEs.
AspectJ is freely available at http://eclipse.org/aspectj.
Prerequisites: Knowledge of Java and some familiarity and experience with AspectJ, equivalent to the material covered in tutorial 4.
Lecture and hands-on exercises
Erik Hilsdale is a researcher at the Palo Alto Research Center. As a member of the AspectJ team, he concentrated on language design, pedagogy and compiler implementation. He has written several conference and workshop publications in programming languages. He is an experienced and energetic instructor in programming languages and has a long history with AspectJ.
Jim Hugunin is a researcher at the Palo Alto Research Center. He built the first Java-based AspectJ compiler and led the subsequent implementation work up to a 1.1 release of the compiler and core tools. He also played a major role in the design of the AspectJ language. Prior to joining the AspectJ team, he designed and implemented JPython/Jython, a widely used implementation of the Python language for the Java platform.
Model Driven Architecture (MDA) is an initiative by the OMG to leverage UML-based modeling techniques to insulate abstract software system specifications from implementation dependencies. The workshop focuses on generative techniques that can be used to realize MDA. We aim to bring together practitioners, researchers, academics, and students to discuss the state-of-the-art of generative techniques in the context of MDA. The OOPSLA'02 workshop on this topic was highly successful and led to the launch of the Generative Model Transformer (GMT) open source initiative.
Topics of interest include:
The goal is to share experience, consolidate successful techniques, and identify the most promising application areas and open issues for future work.
UML (Unified Modeling Language) has been widely accepted by the industry as the lingua franca for modeling object-oriented applications. In recent years, UML profiles such as the Common Warehouse Metamodel (CWM), the UML Profile for Enterprise Distributed Object Computing (EDOC) and the UML Profile for Enterprise Application Integration have defined specialized modeling languages for particular problems. The ISO Reference Model for Open Distributed Processing (RM-ODP) calls for systems to be designed with multiple viewpoints. These viewpoints represent different abstractions and might be implemented as different modeling languages for expression of the particular concepts and relationships relevant to the point of view. These languages should be integrated or otherwise reconciled to achieve a consistent overall system design.
The purpose of this workshop is to explore the characteristics of models of information systems that address areas of concern beyond the structure of programs, and to consider the implications of integrating such models to develop a comprehensive, consistent model of a system.
The objective of this workshop is to have a detailed technical discussion on requirements for future virtual machines and advanced languages from an applications perspective.
Issues such as what features and their virtual machine implementations actually promote object reuse. What has worked in the past? Has the original design goals of the respective participants in their respective object architectures been met. What problems were encountered during the commercial deployment of their respective architectures? What do the participants see as the direction they believe that virtual machine technology will take in the near future, as well as over the long haul?
Web services and service-oriented architectures are promising technology. However, they are still fraught with problems and issues: operational issues, quality of service, functional and methodology related.
In this workshop we aim to identify real industry experiences (successes or failures) in designing and implementing web services based systems. And we look for research papers aiming at identifying and alleviating major bottlenecks and issues related to service-oriented architectures, web services and dynamically re-configurable architectures.
This workshop builds on the Object Oriented Web Services workshops in previous OOPSLA conferences and sets a slightly different direction, aimed at consolidating web services and service-oriented architecture best practices and patterns.
This tutorial gives an in-depth overview of the C# programming language, both as it currently exists and as it is planned to evolve in the near future. An emphasis will be placed on explaining design rationales, making the talk interesting for both programmers and language designers.
Prerequisites: Participants should have a good working knowledge of object-oriented programming. Previous experience with C# and .NET is not required.
Lecture and working code demonstrations
Anders Hejlsberg is a Distinguished Engineer in the Developer Division at Microsoft Corporation. He is the chief designer of the C# programming language and a key participant in the development of the .NET Framework. Before joining Microsoft in 1996, Anders was a Principal Engineer at Borland International. As one of the first employees of Borland, he was the original author of Turbo Pascal and later worked as the Chief Architect of the Delphi product line. Anders studied Engineering at the Technical University of Denmark.
This tutorial presents the issues facing modern high-performance garbage collectors and examines the approaches taken by state-of-the-art garbage collectors.
Participants will gain a deeper insight into the operation of modern, high-performance garbage collectors. The tutorial will enable participants to evaluate the benefits and costs of such garbage collection algorithms, to understand the implications for their code and to make informed choices between collectors.
Prerequisites: Participants must be experienced programmers familiar with basic garbage collection technology. Basic knowledge of OO implementation is useful but not essential.
Lecture, animations, and demonstrations
Richard Jones is a Senior Lecturer and Deputy Director of the Computing Laboratory at the University of Kent. He is the prime author of the book on Garbage Collection. His interests include programming languages and their implementation and visualisation, storage management and distributed systems. He is Coordinator of the UK Memory Management Network of researchers, a member of the Steering Committee of the International Symposium on Memory Management and was Programme Chair for ISMM'98. He has presented several tutorials at OOPSLA and ECOOP.
Eric Jul is a Professor at DIKU, the Dept. of Computer Science, University of Copenhagen where he leads research in distributed, heterogeneous computing. He is co-designer and principal implementer of the Emerald distributed object-oriented programming language. His interests include distributed, OO languages, operating systems support for such languages including distributed storage management (distributed shared memory and garbage collection) and object-oriented design and analysis. At previous ECOOP/OOPLSA conferences he has run a number of workshops and tutorials related to distributed computing and memory management. He was Programme Chair for ECOOP'98.
Static typing aids in earlier error detection, supports compiler optimizations, and provides information to programmers on the intended use of constructs. However, simple static-typing disciplines for object-oriented languages like C++ and Java are so restrictive that programmers are forced to bypass the type system with type casts. Other languages allow more freedom, but require run-time checking to pick up the type errors that their more permissive systems missed.
After surveying problems with existing type systems (illustrated by a series of sample programs), we explain contravariance and covariance issues in type systems, and suggest ways of improving the expressiveness of these systems while retaining static type safety. Constructs introduced include "MyType," "matching," and "F-bounded polymorphism." We include a brief discussion on how the type system and semantics ensure type safety. We apply the concepts in the tutorial to compare the strengths and weaknesses of proposals to extend Java to support genericity based on F-bounded polymorphism, "where" clauses, match-bounded polymorphism, and virtual types. In particular, we cover the advantages and disadvantages of the forthcoming extensions to Java (taken from GJ) to support parametric polymorphism.
Prerequisites: Attendees should be very comfortable with a class-based object-oriented programming languages. Ideally, the attendee should have sufficient experience with type systems as to be frustrated with their limitations.
Kim Bruce is Wells Professor of Computer Science at Williams College. He received his Ph.D. from the University of Wisconsin and has been a visiting professor or scientist at M.I.T., Stanford, and Princeton, among others. A researcher on the types and semantics of object-oriented languages, he has served twice on the OOPSLA program committee, on the program committee of POPL '03, and as chair of the organizing committee of the FOOL workshops on the Foundations of Object-Oriented Languages for many years. He has presented papers at the ECOOP, OOPSLA, and POPL conferences, and is the author of the book, "Foundations of Object-Oriented Languages: Types and Semantics," MIT Press, 2002.
Reflection can help to improve productivity by promoting the development of programs that are easily adapted to requirements changes. Reflection facilitates testing and problem determination by permitting the automation of more tedious tasks. In general, reflection improves the flexibility, extensibility, and reusability of code.
The Java programming language (version 1.4) contains a highly effective reflection facility. This tutorial explains the concept of reflection, the Java metaobjects (including both introspective and intercessional interfaces), the proxy class, and dynamic compilation and class loading. The limits of Java reflection are addressed in the context of what reflection is capable of in general. In addition, the tutorial demonstrates the efficacy of the Java reflection facility for solving practical problems. Such problems include: program/application testing, generation of code, inspection of code, and use of dynamic class loading in a framework for application extension. Finally, we will cover the performance impact of using reflection.
This tutorial is the basis of a book titled "Java Reflection" to be published by Manning Publications.
Prerequisites: Attendees must be competent Java programmers.
Dr. Ira R. Forman works for IBM in Austin. As a member of IBM's Object Technology Products Group, which produced the SOMobjects Toolkit, he worked on the SOM Metaclass Framework. From 1984 to 1991, he worked on distributed systems design in the MCC Software Technology Program. He started working in the area of object-oriented programming in 1982 at the ITT. Dr. Forman received his Ph.D. in Computer Science from the University of Maryland, where he studied under Harlan Mills. His specialties are object-oriented programming, distributed systems, and object composition. He is the coauthor of two books: "Interacting Processes: A Multiparty Approach to Coordinated Distributed Programming" and "Putting Metaclasses to Work: A New Dimension in Object-Oriented Programming."
Nate Forman works for Ticom Geomatics where he designs and programs application frameworks for their products. His specialties are patterns and object-oriented programming. Forman holds a MSE in Software Engineering from the University of Texas at Austin and a BS in Computer Science from the College of Engineering at Cornell University.
This tutorial teaches participants how to apply AspectJ to enterprise application development using J2EE. It demonstrates some of the more advanced capabilities of AspectJ and how they can be used to address concerns such as security, caching, logging with Jakarta Commons, testing with JUnit, and more. The tutorial is based on a J2EE setting working with servlets, JSPs, EJBs and Web Services. It also compares AspectJ to AspectWerkz and JBoss AOP.
Prerequisites: Attendees should have experience doing object-oriented design and implementation for IT applications. Attendees should have already experimented with AspectJ.
Lectures and hands-on exercises
Ron Bodkin is the founder of New Aspects of Security, which extends AspectJ to provide security and privacy management for enterprise applications, and provides consulting on AOP and architecture. Previously, Ron worked for Xerox PARC, where he led the first AspectJ training and implementation projects for customers. Prior to that, Ron was a founder and the CTO of C-bridge, a consultancy that built and customized enterprise applications using Java, XML, and other Internet technologies.
Adrian Colyer is an IBM UK Technical Staff Member with over 10 years of experience in developing enterprise middleware. He leads the open source AspectJ Development Tools for Eclipse project, and is also a committer on the core AspectJ compiler project.
This tutorial covers the salient aspects of the first major revision of the Unified Modeling Language, UML 2.0. It includes background information on what drove the requirements and the design rationale--from the point of view of one of its primary designers. The overall structure of UML 2.0 is described followed by a more detailed description of the most prominent new modeling features illustrated with many examples. The capacity of UML 2.0 to cover the needs of model-driven development methods is also described.
Prerequisites: Attendees must have practical experience in applying object-oriented technologies in general, and the Unified Modeling Language in particular.
Bran Selic works for the Rational Software Group of IBM. He is also an adjunct professor of computer science at Carleton University. He has over 30 years of experience in industry in the design and development of large real-time systems. He is the principal author of a book that pioneered the application of object technology and model-driven development methods in real-time applications. From 1996 onwards, he has participated in the definition of the UML standard and its standard real-time UML profile. He is co-chair of a submission team that defined the first major revision of UML, UML 2.0.
A lot has been written about multithreading, C++, and multithreading in C++. A number of different higher-level threading APIs have been proposed. Some are influenced by object models that are not necessarily appropriate to C++'s own idioms, and some suffer from looking too obviously like C API wrappers, in spite of their specific goal of API independence. In many cases, the resulting object model is less expressive, although far simpler and safer to use, than the underlying API.
This tutorial presents a refined model for threading in C++. The model is simple, idiomatic, and generic, and its thinking is more obviously unchained from the view of thread objects as C API wrappers. It entails a generic-programming approach that is more than simply using templates: it is orthogonal and open. Elements of the resulting thread programming model can also be realized in other programming languages.
Prerequisites: Attendees should be experienced with C++ programming and should have some experience using templates, preferably based on the STL. At least basic familiarity with concurrency concepts is also required.
Kevlin Henney is an independent consultant and trainer. The focus of his work is in programming languages, OO, CBD, UML, patterns, and software architecture. He is a regular columnist for C/C++ Users Journal (online), Application Development Advisor (UK), and JavaSpektrum (Germany), and previously wrote columns in Java Report and C++ Report. He is also a member of the advisory board for Hillside Europe, the program chair for EuroPLoP 2003, and a popular speaker at conferences in the US and Europe.
Program generation has been used for a long time to facilitate the development of enterprise and embedded systems. More recently, its potential for improving object-oriented software development in general has been realized through the use of program generation techniques such as generative programming, product line engineering, and model-driven architectures (MDA).
This tutorial introduces the most important kinds of code generation, such as model transformations, source code generation, source code transformation, byte code rewriting and reflection. We will introduce different code generation technologies, such as template-based generators, frame technology, aspect weaving and AST-based approaches; illustrate when to use them; discuss benefits and drawbacks of each approach; and look at representative tools that support each kind of program generation. Some of these tools will also be demonstrated.
Prerequisites: Attendees should be experienced OO developers or architects and must understand an OO programming language, such as Java, C++ or C#. Familiarity with UML is also required. Previous experience with code generation is not necessary.
Lecture and live demonstrations
Markus works as an independent consultant in software technology and engineering. He focuses on the architecture of large, distributed systems. Markus is the author of several magazine articles and patterns, a regular speaker at conferences, and co-author of Wiley's "Server Component Patterns." Over the last couple of years, Markus has architected and implemented several large enterprise systems in banking, diagnostics and automotive, on various scales. He has used code generation in the context of enterprise and embedded systems. Markus can be reached at email@example.com or via http://www.voelter.de.