Languages

Sunday, 26 October

8:30-17:00 Full day

Tutorial 16: Concepts of Object-Oriented Programming
Workshop 9: The 3rd OOPSLA Workshop on Domain-Specific Modeling
Workshop 15: Multiparadigm Programming with OO Languages (MPOOL'03)
Workshop 16: How to Use Ontologies and Modularization to Explicitly Describe the Concept Model of a Software Systems Architecture

8:30-12:00 Morning

Tutorial 4: Introduction to Aspect-Oriented Programming with AspectJ
Tutorial 7 Programming Internet-Scale Distributed Applications in the 21st Century: BPEL and Beyond

13:30-17:00 Afternoon

Tutorial 10: Advanced Aspect-Oriented Programming with AspectJ

Monday, 27 October

8:30-17:00 Full day

Workshop 3: Generative techniques in the context of MDA
Workshop 8: Multiple Viewpoints for System Modeling
Workshop 21: 2nd International Workshop on Language Agnostic Runtimes and Component Based Architectures
Workshop 22: Web Services and Service-Oriented Architecture Best Practices and Patterns

8:30-12:00 Morning

Tutorial 20: The C# Programming Language
Tutorial 22: Garbage Collection
Tutorial 29 Foundations of Object-Oriented Languages: Types and Language Design

13:30-17:00 Afternoon

Tutorial 27: Java Reflection

Tuesday, 28 October

13:30-17:00 Afternoon

Tutorial 39: Enterprise Aspect-Oriented Programming with AspectJ
Tutorial 40: An Overview of UML 2.0
Tutorial 41 C++ Threading: A Generic-Programming Approach
Tutorial 43 Program Generation: Concepts and Techniques

Wednesday, 29 October

13:30-15:00

Domain-Driven Development: Technology

16 Concepts of Object-Oriented Programming

Sunday, 26 October – 8:30-17:00 Full day

Raimund Ege, Florida International University, ege@cs.fiu.edu

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.

Attendee background

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.

Format

Lecture

Presenter

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).

9 The 3rd OOPSLA Workshop on Domain-Specific Modeling

Sunday, 26 October – 8:30-17:00 Full day

Juha-Pekka Tolvanen, MetaCase Consulting, jpt@metacase.com
Jeff Gray, University of Alabama at Birmingham, gray@cis.uab.edu
Matti Rossi, Helsinki School of Economics, mrossi@hkkk.fi

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.

Workshop topics:

Industry/academic experience reports

  • Approaches to identify constructs for DSMs
  • Novel approaches for code generation from domain-specific models
  • Issues of support/maintenance for systems built with DSMs
  • Evolution of languages in accordance with domain
  • Metamodeling frameworks and languages
  • Tools for supporting DSMs

http://www.cis.uab.edu/info/OOPSLA-DSM03/

15 Multiparadigm Programming with OO Languages (MPOOL'03)

Sunday, 26 October – 8:30-17:00 Full day

Kei Davis, Los Alamos National Laboratory, kei@lanl.gov
Timothy Budd, Computer Science Department, Oregon State University, budd@cs.orst.edu
Joerg Striegnitz, Research Center Juelich, Central Institute for Applied Mathematics (ZAM), j.striegnitz@fz-juelich.de
Peter Van Roy, Department of Computing Science and Engineering, Catholic University of Louvain, pvr@info.ucl.ac.be

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

http://www.multiparadigm.org/mpool03

16 How to Use Ontologies and Modularization to Explicitly Describe the Concept Model of a Software Systems Architecture

Sunday, 26 October – 8:30-17:00 Full day

Petra Becker-Pechau, University of Hamburg, becker@informatik.uni-hamburg.de
Joerg Pechau, EDS, jop@j-o-p.de
Martin Lippert, it-wps Workplace Solutions Ltd., lippert@jwam.org

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

http://swt-www.informatik.uni-hamburg.de/conferences/workshop-oopsla2003.html

4 Introduction to Aspect-Oriented Programming with AspectJ

Sunday, 26 October – 8:30-12:00 Morning

Erik Hilsdale, PARC, hilsdale@parc.com
Jim Hugunin, PARC, hugunin@parc.com

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.

Attendee background

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.

Format

Lecture and demonstration

Presenters

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.

7 Programming Internet-Scale Distributed Applications in the 21st Century: BPEL and Beyond

Sunday, 26 October – 8:30-12:00 Morning

Vivek Sarkar, IBM T.J. Watson Research Center, vsarkar@us.ibm.com
John Field, IBM T.J. Watson Research Center, jfield@us.ibm.com

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.

Attendee background

Prerequisites: Basic knowledge of object-oriented languages, web services, and parallel and distributed computing.

Format

Lecture

Presenters

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.

10 Advanced Aspect-Oriented Programming with AspectJ

Sunday, 26 October – 13:30-17:00 Afternoon

Erik Hilsdale, PARC, hilsdale@parc.com
Jim Hugunin, PARC, hugunin@parc.com

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.

Attendee background

Prerequisites: Knowledge of Java and some familiarity and experience with AspectJ, equivalent to the material covered in tutorial 4.

Format

Lecture and hands-on exercises

Presenters

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.

3 Generative techniques in the context of MDA

Monday, 27 October – 8:30-17:00 Full day

Jorn Bettin, SoftMetaWare, jorn.bettin@softmetaware.com
Ghica van Emde Boas, Bronstee.com Software & Services, emdeboas@bronstee.com
Aditya Agrawal, Vanderbilt University, Aditya.Agrawal@vanderbilt.edu
Ed Willink, Thales Research, Ed.Willink@thalesgroup.com
Jean Bezivin, frUniversity of Nantes, France, Jean.Bezivin@sciences.univ-nantes

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:

  • synergy between MDA, components and generative techniques;
  • implementing domain specific languages on the basis of the UML [2.0] Infrastructure;
  • modeling variability in functionality within product lines;
  • notations for model-to-model transformations;
  • model weaving and model transformation;
  • pre and post-conditions for transformations;
  • transformation and traceability;
  • organization of hierarchical transformation libraries; transformations as assets;
  • applications of higher level transformations (transformations generating transformations);
  • verification of transformation systems;
  • a possible definition of a common standard notation for model transformation within the context of the MDA;
  • styles of model-driven generators;
  • model-driven template languages (language design, template execution environment, debugging, template editors, management of template code);
  • specification of heuristics and manual design decisions
  • use of XSLT, XQuery and other similar tools for MDA;
  • generation of code and non-code artifacts (e.g. tests, measures, etc.);
  • influence of MDA on software architecture;
  • MDA and agile development;
  • industrial applications of MDA.

The goal is to share experience, consolidate successful techniques, and identify the most promising application areas and open issues for future work.

http://www.softmetaware.com/oopsla2003/mda-workshop.html

8 Multiple Viewpoints for System Modeling

Monday, 27 October – 8:30-17:00 Full day

Fred Cummins, EDS, fred.cummins@eds.com
Cory Casanave, Data Access Technologies, cory-c@enterprise-component.com
William Frank, Domain Architects, wff@domainarchitects.com
Stan Hendryx, Hendryx Associates, stan@HendryxAssoc.com
Steven Mellor, Project Technology, steve@projtech.com
Joaquin Miller, Domain architects, joaquin@acm.org

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.

http://www.enterprise-component.com/oopsla2003/

21 2nd International Workshop on Language Agnostic Runtimes and Component Based Architectures

Monday, 27 October – 8:30-17:00 Full day

Yahya Mirza, Aurora Borealis Software, yahya_mirza@hotmail.com
David Simmons, Smallscript LLC, David.Simmons@smallscript.com
Mario Wolczko, Sun Microsystems, mario@eng.sun.com
Shawn Woods, Microsoft, shawnwoo@microsoft.com

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?

http://www.aurorasoft.net/workshops/lar03/lar03home.htm

22 Web Services and Service-Oriented Architecture Best Practices and Patterns

Monday, 27 October – 8:30-17:00 Full day

Ali Arsanjani, IBM Corporation, arsanjan@us.ibm.com
Kerrie Holley, IBM, holley@us.ibm.com

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.

http://www.arsanjani.com/oopsla2003/webservices.htm

20 The C# Programming Language

Monday, 27 October – 8:30-12:00 Morning

Anders Hejlsberg, Microsoft Corporation, andersh@microsoft.com

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.

Attendee background

Prerequisites: Participants should have a good working knowledge of object-oriented programming. Previous experience with C# and .NET is not required.

Format

Lecture and working code demonstrations

Presenter

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.

22 Garbage Collection

Monday, 27 October – 8:30-12:00 Morning

Richard Jones, University of Kent at Canterbury, R.E.Jones@ukc.ac.uk
Eric Jul, University of Copenhagen, eric@diku.dk

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.

Attendee background

Prerequisites: Participants must be experienced programmers familiar with basic garbage collection technology. Basic knowledge of OO implementation is useful but not essential.

Format

Lecture, animations, and demonstrations

Presenters

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.

29 Foundations of Object-Oriented Languages: Types and Language Design

Monday, 27 October – 8:30-12:00 Morning

Kim Bruce, Williams College, kim@cs.williams.edu

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.

Attendee background

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.

Format

Lecture

Presenter

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.

27 Java Reflection

Monday, 27 October – 13:30-17:00 Afternoon

Ira Forman, IBM, formani@us.ibm.com
Nate Forman, Ticom Geomatics, nforman@austin.rr.com

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.

Attendee background

Prerequisites: Attendees must be competent Java programmers.

Format

Lecture

Presenters

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.

39 Enterprise Aspect-Oriented Programming with AspectJ

Tuesday, 28 October – 13:30-17:00 Afternoon

Ron Bodkin, New Aspects of Security, rbodkin@newaspects.com
Adrian Colyer, IBM UK, adrian_colyer@uk.ibm.com

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.

Attendee background

Prerequisites: Attendees should have experience doing object-oriented design and implementation for IT applications. Attendees should have already experimented with AspectJ.

Format

Lectures and hands-on exercises

Presenters

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.

40 An Overview of UML 2.0

Tuesday, 28 October – 13:30-17:00 Afternoon

Bran Selic, IBM Software Group - Rational Software, bselic@rational.com

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.

Attendee background

Prerequisites: Attendees must have practical experience in applying object-oriented technologies in general, and the Unified Modeling Language in particular.

Format

Lecture

Presenter

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.

41 C++ Threading: A Generic-Programming Approach

Tuesday, 28 October – 13:30-17:00 Afternoon

Kevlin Henney, Curbralan Limited, kevlin@curbralan.com

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.

Attendee background

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.

Format

Lecture

Presenter

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.

43 Program Generation: Concepts and Techniques

Tuesday, 28 October – 13:30-17:00 Afternoon

Markus Völter, Independent consultant, voelter@acm.org

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.

Attendee background

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.

Format

Lecture and live demonstrations

Presenter

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 voelter@acm.org or via http://www.voelter.de.

Technology

Wednesday, 29 October – 13:30-15:00

Chair: John Vlissides, IBM T. J. Watson Research Center, ddd@oopsla.acm.org

13:30 - 14:00
XAspects: An Extensible System for Domain-Specific Aspect Languages

Macneil Shonle, Northeastern University, mshonle@ccs.neu.edu
Karl Lieberherr, Northeastern University, lieber@ccs.neu.edu
Ankit Shah, Northeastern University, ankit@ccs.neu.edu

Current general aspect-oriented programming solutions fall short of helping the problem of separation of concerns for several concern domains. Because of this limitation good solutions for these concern domains do not get used and the opportunity to benefit from separation of these concerns is missed. By using XAspects, a plug-in mechanism for domain-specific aspect languages, separation of concerns can be achieved at a level beyond what is possible for object-oriented programming languages. As a result, XAspects allows for certain domain-specific solutions to be used as easily as a new language feature.
Keywords: Aspect-oriented programming, — programming, language extensions, domain-specific languages.

14:00 - 14:30
The Power of Symmetry: Unifying Inheritance and Generative Programming

DeLesley Hutchins, MZA Associates Corporation, hutchins@mza.com

I present the Ohmu language, a unified object model which allows a number of "advanced" techniques such as aspects, mixin layers, parametric polymorphism, and generative components to be implemented cleanly using two basic concepts: block structure and inheritance. I argue that conventional ways of defining classes and objects have created artificial distinctions which limit their expressiveness. The Ohmu model unifies functions, classes, instances, templates, and even aspects into a single construct – the structure. Function calls, instantiation, aspect-weaving, and inheritance are likewise unified into a single operation – the structure transformation. This simplification eliminates the distinction between classes and instances, and between compile-time and run-time code. Instead of being compiled, programs are reduced using partial evaluation, in which the interpreter is invoked at compile-time. Within this architecture, standard OO inheritance becomes a natural vehicle for creating meta-programs and automatic code generators— the key to a number of recent domain-driven programming methodologies.

14:30 - 15:00
Domain Driven Web Development With WebJinn

Sergei Kojarski, Northeastern University, kojarski@ccs.neu.edu
David Lorenz, Northeastern University, lorenz@ccs.neu.edu

Web application development cuts across the HTTP protocol, the client-side presentation language (HTML, XML), the server-side technology (Servlets, JSP, ASP, PHP), and the underlying resource (files, database, information system). Consequently, web development concerns including functionality, presentation, control, and structure cross-cut, leading to tangled and scattered code that is hard to develop, maintain, and reuse. In this paper we analyze the cause, consequence, and remedy for this crosscutting. We distinguish between intra-crosscutting that results in code tangling and inter-crosscutting that results in code scattering. To resolve inter-crosscutting, we present a new web application development model named XP that introduces extension points as place-holders for structure-dependent code. We present another model named DDD that incorporates XP into the Model-View-Controller (MVC) model to resolve both intra- and inter-crosscutting. WebJinn is a novel domain-driven web development framework that implements the DDD model. WebJinn has been used to develop web applications at several web sites. Domain driven web development with WebJinn benefits from a significant improvement in code reuse, adaptability, and maintainability.