Home · Schedule · Tracks · Recommendations · Registration

Technologies

Sunday, 26 October

8:30-17:00 Full day

Workshop 9: The 3rd OOPSLA Workshop on Domain-Specific Modeling
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 2: Introduction to Concurrent Programming in Java
Tutorial 4: Introduction to Aspect-Oriented Programming with AspectJ

13:30-17:00 Afternoon

Tutorial 8: Patterns @ Work
Tutorial 9 Java Concurrency Utilities: Tools for Managing Multi-threading
Tutorial 10: Advanced Aspect-Oriented Programming with AspectJ
Tutorial 12 Successful Web Services and Service-Oriented Architectures: Beyond the Hype
Tutorial 14: An Introduction to the Common Language Infrastructure (CLI)

Monday, 27 October

8:30-17:00 Full day

Tutorial 34: Developing Java Applications for Small Devices Using Eclipse
Workshop 1: Reuse in Constrained Environments
Workshop 3: Generative techniques in the context of MDA
Workshop 5: The Twelfth OOPSLA Workshop on Behavioral Semantics— Striving for Simplicity
Workshop 10: Pervasive Computing; going beyond Internet for small screens
Workshop 18 Bridging the Gap: Examining Approaches that Connect Business Requirements to Enabling Technology Solutions
Workshop 19: Eclipse Technology eXchange

8:30-12:00 Morning

Tutorial 22: Garbage Collection
Tutorial 23: Beyond the Gang of Four
Tutorial 26: Patterns for High Performance Systems

13:30-17:00 Afternoon

Tutorial 28: Enterprise Integration Patterns
Tutorial 33: From Component Reuse to Asset-Based Software Engineering

Tuesday, 28 October

13:30-17:00 Afternoon

Tutorial 39: Enterprise Aspect-Oriented Programming with AspectJ
Tutorial 43 Program Generation: Concepts and Techniques

Wednesday, 29 October

13:30-17:00 Afternoon

Tutorial 47: Enterprise Application Integration with J2EE and .NET
Tutorial 49: Extending Enterprise Systems with Mobile/Wireless Applications
Tutorial 50: Understanding Circa-2003 XML Technologies

Thursday, 30 October

8:30-12:00 Morning

Tutorial 55 J2EE in Practice: Architectural Variations in the Context of Enterprise Systems
Tutorial 56: Model-Driven Architecture

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/

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

2 Introduction to Concurrent Programming in Java

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

David Holmes, DLTeCH Pty Ltd, dholmes@dltech.com.au
Doug Lea, State University of New York (SUNY) at Oswego, dl@cs.oswego.edu

Concurrent programming has mostly been the domain of systems programmers rather than application developers, but Java's support for concurrency has enticed many to try their hand at building concurrent applications. Concurrent programming poses many traps for the unwary, however.

This tutorial demonstrates various design patterns and techniques for constructing concurrent applications in Java and for managing that concurrency. On the language side, we examine Java's mechanisms to support concurrent programming. On the design side, we explore object structures and design rules that can successfully resolve the competing forces (safety, liveness, efficiency, coordination, reusability) present in concurrent software design problems.

Attendee background

This tutorial targets anyone involved, or planning to get involved, in the development of concurrent object-oriented applications.

Prerequisites: Attendees should be familiar with basic OO concepts and must have a working knowledge of the Java programming language.

Format

Lecture

Presenters

David Holmes is Director and Chief Scientist of DLTeCH Pty Ltd, located in Brisbane, Australia. His work with Java technology has focused on concurrency and synchronization support in the language and virtual machine and he is currently working on a real-time Java virtual machine. David is a member of the expert group for JSR-166 "Concurrency Utilities" being developed under the Java Community Process. He has presented tutorials on concurrent Java programming and design at numerous international object-oriented programming conferences. Along with Ken Arnold and James Gosling, he is a co-author of the book "The Java Programming Language - Third Edition". David completed his Ph.D. at Macquarie University, Sydney, in 1999, in the area of synchronization within object-oriented systems.

Doug Lea is a professor of Computer Science at the State University of New York at Oswego. He is author of the Java Series book "Concurrent Programming in Java: Design Principles and Patterns," co-author of the book "Object-Oriented System Development," and the author of several widely used software packages, as well as articles and reports on object-oriented software development. He is on the expert groups of numerous Java Specification Requests including JSR-166 "Concurrency Utilities" and JSR-133 "Java Memory Model".

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.

8 Patterns @ Work

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

Frank Buschmann, Siemens AG, Corporate Technology, Frank.Buschmann@siemens.com

This tutorial illustrates the application of design patterns by example. We present in detail a real-world system and describe how it is designed with patterns, with a focus on distribution and concurrency, flexibility, and components. In particular, we will re-play the process of the system's construction step by step, discuss the design problems that occur, present one or more patterns that can help to address these problems, discuss which of the alternative patterns we selected and why, and show how we actually applied the selected patterns. This sequence illustrates how the design of the system slowly evolves towards the final architecture. We will also see that using patterns in practice is influenced by many factors: concrete constraints and requirements set by the application under development, limited or overstated understanding of particular patterns, varying developer skills, and also personal preferences. A major lesson that we can learn from this discussion is that there exists no "right pattern" for addressing a particular design problem, but rather, different patterns apply in different situations.

A reflection on the case study leads us to general guidelines and golden rules for applying patterns in practise, and we discuss how these guidelines and rules aid in building high-quality software with predictable properties. The tutorial concludes with a summary of our experiences from several projects in which we applied patterns: what worked, what could be improved, and what we learned.

Attendee background

Prerequisites: Attendees are expected to have sound knowledge of object technology, and basic knowledge of both UML notation and the pattern concept.

Format

Interactive lecture

Presenter

Frank Buschmann is senior principal engineer at Siemens Corporate Technology in Munich, Germany. His interests include Object Technology, Frameworks and Patterns. Frank has been involved in many software development projects. He is leading Siemens' pattern research activities. Frank is co-author of "Pattern-Oriented Software Architecture -- A System of Patterns" and "Pattern-Oriented Software Architecture -- Patterns for Concurrent and Networked Objects".

9 Java Concurrency Utilities: Tools for Managing Multi-threading

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

Doug Lea, State University of New York (SUNY) at Oswego, dl@cs.oswego.edu
David Holmes, DLTeCH Pty Ltd., dholmes@dltech.com.au

Semaphores and mutexes, latches and gates, pools and executors - these are all tools for managing threads within our applications. Each one has its own properties and purpose, and when used correctly, each can greatly simplify concurrent program design.

The Java programming language has turned a generation of applications programmers into concurrent programmers through its direct support for multithreading. However, the Java concurrency primitives are just that: primitive. You can build many concurrency utilities from them, but doing so requires great care, as concurrent programming poses many traps for the unwary. Designing concurrent programs that can successfully resolve the competing forces of safety, liveness, efficiency, coordination, and reusability, is a task that can be greatly aided through the use of a good set of tools - a good concurrency utility library.

This tutorial presents the components of a proposed concurrency utility library for the Java platform and being developed under JSR-166. We will look at the purpose and properties of each tool and how it fits into the concurrent design puzzle. We will also look at proposed extensions to the Java concurrency primitives.

Attendee background

This tutorial targets anyone involved, or planning to get involved, in the development of concurrent object-oriented applications in Java.

Prerequisites: Attendees must be familiar with basic OO concepts and have a working knowledge of the Java programming language. Familiarity with Java's threading and synchronization mechanisms is desirable, but not essential.

Format

Lecture

Presenters

Doug Lea is a professor of Computer Science at the State University of New York at Oswego. He is author of the Java Series book "Concurrent Programming in Java: Design Principles and Patterns," co-author of the book "Object-Oriented System Development," and the author of several widely used software packages, as well as articles and reports on object-oriented software development. He is on the expert groups of numerous Java Specification Requests including JSR-166 "Concurrency Utilities" and JSR-133 "Java Memory Model".

David Holmes is Director and Chief Scientist of DLTeCH Pty Ltd, located in Brisbane, Australia. His work with Java technology has focused on concurrency and synchronization support in the language and virtual machine and he is currently working on a real-time Java virtual machine. David is a member of the expert group for JSR-166 "Concurrency Utilities" being developed under the Java Community Process. He has presented tutorials on concurrent Java programming and design at numerous international object-oriented programming conferences. Along with Ken Arnold and James Gosling, he is a co-author of the book "The Java Programming Language - Third Edition". David completed his Ph.D. at Macquarie University, Sydney, in 1999, in the area of synchronization within object-oriented systems.

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.

12 Successful Web Services and Service-Oriented Architectures: Beyond the Hype

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

Ali Arsanjani, IBM Corporation and Maharishi University of Management, arsanjan@us.ibm.com
Bruce Anderson, IBM Corporation, bruce_anderson@uk.ibm.com

This intense and unique tutorial provides an introduction and step-by-step walkthrough of the state of the art of Web services (WS) and Service-oriented Architectures (SOA).

The tutorial presents overviews of key web services standards (including WS-I, WSIF, WSIL, SOAP, WSDL, UDDI) considerations for their use, and some tools and technologies (including Apache Axis and related projects) that can be employed to implement them. Next, it presents an architectural blueprint for web services architecture that can server as a basis for most projects. With these standards, considerations, tools and blueprint in hand, we present a set of concrete process steps that lead to the realization of an SOA.

The tutorial will then present a set of patterns for the design and implementation of web services based architectures including Business Service, Service Gateway, SOAP Document, and SOAP Method. We also discuss methods for assessment that can be used as checklists by architects who wish to evaluate web services architectures.

Finally, to tie these togather, we will present two case studies, from the financial services and retail purchasing domains.

Attendee background

Prerequisites: Basic knowledge of object-oriented development, and some knowledge of software architecture, design and implementation, are required.

Format

Lecture and hands-on exercises

Presenters

Ali Arsanjani has over 19 years of industrial experience. He is a Senior Consulting I/T Architect for IBM's National E-business Application Development Center of Competency, where he leads the Component-based Development and Integration Competency area. He has been architecting n-tier e-business systems based on object, component, and service-oriented technologies for IBM's larger clients. His areas of experience and research include component-based development, service-oriented architectures, business rules modeling and implementation, creation and evolution of reusable assets, extending methods for CBD, building business frameworks and components and incorporating patterns and pattern languages to build resilient and stable software architectures. He has been actively speaking and publishing in these areas for a variety of industrial and academic audiences.

Bruce Anderson is a Senior Consultant in IBM's Component Technology Services. He specialises in working with customer organisations to create powerful component- and object-based solutions, and in helping individuals to develop their knowledge and understanding. Typically, Mr. Anderson leads planning and definition work, and mentoring programme leaders, project managers or architects into their roles.

14 An Introduction to the Common Language Infrastructure (CLI)

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

Damien Watkins, Director - Project 42 / Research Associate - DSTC, damien@project42.net

A number of Component-Based Architectures (CBAs) have been developed to facilitate the interoperability of software components that are written in different programming languages. The most widely known and used of these is OMG's Common Object Request Broker Architecture (CORBA) and Microsoft's Component Object Model (COM) and Distributed COM (DCOM). Although not specifically designed to provide language interoperability, many Java-based technologies, such as Enterprise Java Beans (EJB), also adhere to the principles of a CBA. The Common Language Infrastructure (CLI) is the latest CBA to be developed, and it builds on many of the lessons learned from previous architectures.

In this tutorial, we will look at the major components of the CLI. The CLI is an ECMA standard on which Microsoft has built three implementations: the .NET Framework, the Compact Framework and the Shard Source CLI. The CLI is also the specification on which non-Microsoft implementations, such as Ximian's Mono, are based.

Attendee background

Prerequisites: Attendees should have experience programming in an object-oriented programming language. Knowledge of a distributed/component architecture, such as CORBA or COM, is helpful. No familiarity with the CLI is required.

Format

Lecture

Presenter

Dr. Damien Watkins is the founder and Managing Director of the software company "Project 42" and a Research Associate with the Distributed Systems and Technologies Centre. Prior to commencing Project 42, Damien lectured at the School of Computer Science and Software Engineering at Monash University. Damien is the primary author of "Programming in the .NET Environment" (Addison-Wesley 2003) and several papers on COM/DCOM, CORBA and the .NET Framework. Damien has presented tutorials on software architectures at OOPSLA 2002, SIGCSE 2002, TOOLS Pacific/Europe and the Microsoft Research Faculty Summit 2001/2002.

34 Developing Java Applications for Small Devices Using Eclipse

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

Chris Laffra, IBM Canada, Chris_Laffra@ca.ibm.com
Michael van Meekeren, IBM Canada, Michael_van_Meekeren@ca.ibm.com

Eclipse is an increasingly popular Java-based open-source tooling platform. The platform provides support for Java program development, such as editing, compiling and debugging, and it is readily extensible through its plug-in mechanism. We have been involved in the development of a set of plug-ins that support the building and launching of embedded applications (with support for various platforms, such as J2ME/MIDP, PocketPC and PalmOS). We will show how applications can be developed, compiled, analyzed and compressed to fit on really small devices. We will demonstrate how to debug applications running in either an emulator or on a real device.

We will also discuss how these Eclipse plug-ins were developed, what trade-offs we encountered, and what lessons we learned, and we will offer suggestions that will benefit (future) Eclipse plug-in writers. The tutorial will also include a demonstration of writing an actual plug-in for Eclipse.

This technical tutorial will include lots of actual code and reports on practical experience. We will provide background information on developing Java applications for resource-constrained environments, such as PalmOS, and explain what Java standardization processes are under way in this area.

Attendee background

Prerequisites: Attendees must have basic experience with Java and any interactive development environment.

Format

Lecture and demonstrations

Presenters

Chris Laffra obtained his PhD at the Erasmus University of Rotterdam. At IBM Research, he worked on visualization of object-oriented programs. Then he worked at Morgan Stanley, a Wall Street investment bank, on user interface tool development, and component infrastructures. After returning to IBM Research, Chris worked on Java tools to enable program analysis, debugging, visualization, compression, and optimization. Chris led the OTI Amsterdam lab for 3.5 years and now works for IBM from its Ottawa lab, contributing to Eclipse-based development tools for embedded Java applications.

Michael Van Meekeren obtained his BCS from Acadia in 1994. He is a senior developer with IBM Ottawa labs (formerly known as Object Technology International), and has played an active role in the development of IBM Smalltalk, VisualAge for Java and WebSphere Studio Device Developer.

1 Reuse in Constrained Environments

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

Markus Voelter, independent consultant, voelter@acm.org
Michael Kircher, Siemens AG, Corporate Technology, michael.kircher@siemens.com
Christa Schwanninger, Siemens AG, Corporate Technology, christa.schwanninger@siemens.com
Uwe Zdun, New Media Lab, Vienna University of Economics and BA, zdun@acm.org
Alexander Schmid, Personal, alexander.schmid@alegu.de

The main goals of software reuse are to increase quality, reduce cost, and shorten development cycles. The interesting question in this context is: How to achieve reuse in constrained environments? In desktop and enterprise systems, object-orientation, components, frameworks, service-oriented architectures and, most recently, model-driven development are proposed as cornerstones for efficient reuse. In constrained environments (i.e. embedded and real time systems, PDAs, smart phones, settop boxes) reuse is not as simple, because most reuse techniques imply some kind of overhead: memory, performance, or determinism.

This workshop explores practical reuse techniques for constrained environments. Potential topics include, but are not limited to:

  • middleware technologies
  • quality of service provisions
  • code composition and weaving
  • code generation, composition and weaving
  • small and efficient frameworks
  • component infrastructures for embedded systems
  • model driven development
  • static variability and metaprogramming
  • component composition
  • design and architectural patterns

http://www.voelter.de/conferences/oopsla03.html

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

5 The Twelfth OOPSLA Workshop on Behavioral Semantics— Striving for Simplicity

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

Haim Kilov, Independent Consultant and Stevens Institute of Technology, haimk@acm.org
Kenneth Baclawski, Northeastern University, ken@baclawski.com

The goal of this workshop is to foster precise, explicit, and elegant OO specifications of business and system semantics, independently of any (possible) realization. Substantial progress has been made in these areas, both in academia and in industry. However, in too many cases only lip service to semantic issues has been provided, and as a result the systems we build or buy are all too often excessively complex or (this is not an exclusive or) are not what they are supposed to be. Doing better than that requires both a clear understanding of the problem semantics within the context of their business and technological environments, and an abstract, precise and explicit specification of that semantics.

The specific theme this year is on striving for simplicity. In order to simplify IT systems, we need to use abstraction — in C.A.R.Hoare's words, "only abstraction enables a manager or a chief programmer to exert real technical control". The same considerations apply to understanding, modeling and making (strategic, tactical and operational) decisions about businesses.

http://www.ccs.neu.edu/home/kenb/oopsla2003

10 Pervasive Computing; going beyond Internet for small screens

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

Steffen Schaefer, IBM Global Services, steffens@acm.org
Rob van den Berg, Siemens, rob@stlab.nl
Steve Marney, EDS, steve.marney@eds.com

Pervasive Computing has become a reality and is further emerging. And even though Pervasive Computing is still in its infancy, no one can deny its potential to change how we live and do business. Pervasive Computing is pointing toward a future in which the networking web will be extended to an ever larger number of players, to smaller machines, houses, appliances, etc., which are increasingly becoming more intelligent. Applications and architectures are becoming multi modal and aware of their context. This web will allow machines to interact with other machines and humans. The sheer number of players interacting with each other and their penetration in our daily lives, such as household appliances, is going to make the impact even more formidable.

In some respects, pervasive solutions contain many elements from standard e-Business systems and are implemented with the same or similar technology. However, the combination of the pervasiveness of computing functionality and internet access, together with possibilities such as the remote monitoring of events and pushing information to users and machines, or the creation of location-aware services, is a new paradigm. Clearly, the well-known Web 'Request/Response' model, as implemented through WAP or i-mode is not enough. Disconnected Work, Intelligent Notification, Ad Hoc Networks, and Data Replication are just a few samples usage patterns where Pervasive Computing goes beyond 'internet for small screens'.

We believe Object Technology is playing a major part in shaping up this new computing paradigm. In some ways, objects can be regarded as becoming highly dynamic and more pervasive, 'living' on even the smallest device. The computing model is becoming even more distributed, possibly using Web Services as the prime means for cooperation.

workshop will bring together practitioners who have been actively involved in the development of Pervasive Computing solutions, researchers who have been working in this area, and people who have been involved in the definition of standards. The goal is to identify recurring architecture themes and patterns typically used to build such systems, or raise issues and gaps for implementation that need to be resolved.

The workshop is a sequel to similar sessions from the previous years at OOPSLA. It will start off with a short presentation of accepted papers and will then be highly interactive, aiming for tangible outcomes, such as sketches of reference architectures or patterns identified in this field.

http://jeckstein.com/oopsla/pervasive-computing/

18 Bridging the Gap: Examining Approaches that Connect Business Requirements to Enabling Technology Solutions

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

Ralph Hodgson, TopQuadrant, Inc., ralph@topquadrant.com
Dave Parrish, Management Science Associates, Inc., dparrish@msa.com
Christine Brautigam, Direct Dynamics, Inc., christine@directdynamics.biz
Dr. Robert F. Coyne, TopQuadrant, Inc., robert@topquadrant.com

To ensure return on technology investments, companies need to align IT projects to their Business Strategy. Today a technology solution has many stakeholders, requiring systems to be developed in a multi-stakeholder context.

The key stakeholders include:

  • End-users of the solution who will have to live with the solution and will ultimately decide how successful it is – often they are external customers of the company
  • The Enterprise that is hoping to realize a business ROI from the solution
  • IT departments or other technical organizations responsible for implementing the solution
  • Technology vendors whose technology provides underpinnings and components of the solution

Stakeholders often have conflicting objectives. Moreover, differing sub-cultures and ways of working and communicating contribute to communication barriers and the possibility of project failure.

This workshop explores ways of realizing an effective “bridge” to close communication gaps and to create a shared vision and plan for realization among different stakeholders. The benefits of having an effective way to translate a Business Strategy into optimal technology solutions include:

  • Improved likelihood of project success
  • Increased enterprise vitality through effective use of technology
  • Greater ROI of technology spending

The workshop will look into approaches for accelerated solution design that can reliably translate and connect core business requirements into the best choices for enabling technology and software implementations. In particular, the workshop will solicit submissions that summarize substantive candidates of such approaches for presentation and subsequent cross-comparison and analysis. Workshop attendees will discuss, analyze and attempt to distill the essence of what makes these approaches work – looking for a core set of similar features, activities, constructs and results produced that have proven to be effective and reliable.

One possible example of such a common feature -- the use of solution stories -- appears to foster a common understanding of ideas and confidence in proposed capabilities for given domains. As one of the probable items of focus, the workshop will seek to confirm that this is a common feature, and to understand why. The overall goal and result of the workshop will be to catalog the most important, common features or activities of the best approaches and how and why each works, whether by itself or in combination with the rest.

http://www.topquadrant.com/workshops/oopsla2003.htm

19 Eclipse Technology eXchange

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

Michael Burke, IBM TJ Watson Research Center, mgburke@us.ibm.com
Erich Gamma, IBM Object Technology International, Zurich, erich_gamma@ch.ibm.com
Gabby Silberman, IBM Center for Advanced Studies, gabbys@ca.ibm.com
Mary Lou Soffa, Pittsburgh University, soffa@cs.pitt.edu

The eclipse platform (http://www.eclipse.org) is designed for building integrated development environments (IDEs) for object-oriented application development. The eclipse Technology eXchange workshop will feature presentations of about 12 papers that describe the use of the eclipse open source as a code base for teaching and research, or for support of a community service. The presenters will report on their projects and explore potential new uses of eclipse and improved usability of the core eclipse technology. Technical leaders of the eclipse community will be available throughout the workshop to answer questions and participate in the technology exchange.

keywords: object-oriented programming, integrated development environment

See the call for papers and other information: http://witanweb.ca/eTX/

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.

23 Beyond the Gang of Four

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

Frank Buschmann, Siemens AG, Corporate Technology, Frank.Buschmann@siemens.com
Kevlin Henney, Curbralan Ltd., kevlin@curbralan.com

When software developers mention design patterns, the chances are that they are talking about Design Patterns, the classic book by the Gang of Four, rather than design patterns in general. Even when they are talking about the pattern concept, as opposed to specific patterns, they often think in terms of the form and idea presented in GoF, and rarely beyond.

Since the publication of the seminal work by the GoF in 1994, however, a great deal of research and practice in patterns has led to a better understanding of both the pattern concept and the strengths and weaknesses of the GoF patterns themselves.

This tutorial revisits the GoF patterns, reflects on them, deconstructs them, and re-evaluates them from the practitioner's perspective: why patterns such as Abstract Factory, Builder, Flyweight, Command, and others are missing a vital ingredient to be proper parts of an architectural vocabulary; why Iterator is not always the best solution for traversing aggregates; why State is not the only state pattern; why some patterns, such as Bridge, are more than one pattern; and what you can do about it.

Attendee background

Prerequisites: Sound knowledge of the pattern concept and the GoF patterns are required.

Format

Interactive lecture

Presenters

Frank Buschmann is senior principal engineer at Siemens Corporate Technology in Munich, Germany. His interests include Object Technology, Frameworks and Patterns. Frank has been involved in many software development projects. He is leading Siemens' pattern research activities. Frank is co-author of "Pattern-Oriented Software Architecture -- A System of Patterns" and "Pattern-Oriented Software Architecture -- Patterns for Concurrent and Networked Objects".

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.

26 Patterns for High Performance Systems

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

Robert Hanmer, Lucent Technologies, hanmer@lucent.com

Good performance, reliability, and maintainability are designed into software. The tutorial presents a guided tour through existing, industry-tested patterns that aid in the design of high performance, real-time, distributed and embedded systems, using a telecommunications system to structure the tour. The tour highlights various collections of patterns, as well as their sources -- books, conference notes and websites. Our objective is to make participants aware of these valuable resources that can greatly simplify their design work. By reusing a proven solution to frequently occurring problems, their efforts can be focused on the truly new portions of their design.

Attendee background

Prerequisites: Attendees should have a basic understanding of what a pattern is. No prior knowledge in any specific domain is expected. Attendees will gain the most from the tutorial if they have considered the general performance and reliability constraints with which they most frequently work.

Format

Lecture

Presenter

Robert Hanmer is a Consulting Member of Technical Staff in the Convergence Solutions R&D organization of Lucent Technologies. He began working with patterns in 1995, capturing the patterns of a large telephone switching system and also of telecommunications systems in general. He has served as Program Chair at several PLoP conferences. He is active in the Hillside Group, as well as the TelePLoP group, which is an informal collection of pattern advocates and authors interested in the field of telecommunications. He has authored many patterns that discuss key solutions for high performance systems.

28 Enterprise Integration Patterns

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

Bobby Woolf, Independent Consultant, woolf@acm.org
Gregor Hohpe, ThoughtWorks, Inc., gregor@hohpe.com

It's no longer enough to be able to develop fantastic applications; now they have to be able to coordinate with each other as well. Whether your sales application must interface with your inventory application, your procurement application must integrate with an auction site, or your PDAs PIM must synchronize with the corporate calendar server, just about any application can be made better by integrating it with other applications. Customers expect an integrated, single-application experience, regardless of how internal functionality may be split across applications, so applications must be integrated.

This tutorial will teach you how to use messaging to integrate applications effectively by presenting a set of patterns--best practices that have been proven over time in a variety of integration projects. These patterns will teach you how to use message-based communication successfully.

This tutorial is based on technology-agnostic patterns and applies to a variety of messaging technologies, ranging from the Java Message Service (JMS) API in J2EE, and the System.Messaging namespace in Microsoft .NET, to enterprise application integration (EAI) and middleware products from vendors such as IBM, TIBCO, WebMethods, SeeBeyond, Vitria and others.

Attendee background

This tutorial is intended for enterprise application architects, designers, and developers who have basic familiarity with messaging tools and technologies, but wish to learn how best to use messaging to achieve enterprise application integration, and wish to be able to better communicate about these issues.

Prerequisites: Basic familiarity with messaging tools and technologies.

Format

Lecture

Presenters

Bobby Woolf has been developing multi-tier object-oriented business applications for thirteen years using Java/J2EE, Smalltalk, and embedded systems for messaging, workflow, business rules, and persistence. One of his specialties is developing architectures that integrate workflow, EJB, and JMS. He has presented tutorials at OOPSLA and JavaEdge, published articles in Java Developer's Journal and on the DeveloperWorks web site, published patterns in all of the PLoPD books, and is a co-author of The Design Patterns Smalltalk Companion. He is also a co-author of the upcoming book "Enterprise Integration Patterns" from Addison-Wesley.

Gregor Hohpe leads the Enterprise Integration Services competency at ThoughtWorks, Inc., a provider of application development and integration services. Over the past years, he has been helping clients around the globe design and implement enterprise integration solutions. His current work focuses on the application of agile methods and design patterns to the development of integration solutions. Gregor is a frequent speaker at technical conferences and has published a number of articles presenting a no-hype view on enterprise integration, Web services and Service-Oriented Architectures. He is a co-author of the upcoming book "Enterprise Integration Patterns."

33 From Component Reuse to Asset-Based Software Engineering

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

Martin Griss, Martin Griss Associates, martin@griss.com

This tutorial presents an introduction to the interlocking business, organizational and technical issues that influence large-scale software reuse and asset-based software engineering. Asset reuse is one of the most significant enablers for productivity improvements; it appears simple at first glance, yet is difficult to execute. Most organizations do not know how to effectively structure a reuse program to match their business and software goals. We describe three primary flavors of reuse: Facilitated, Managed and Designed. An organization selects and practices one or more of these flavors of reuse by varying the amount of proactive management of assets and process; proactive design and architecture of assets to enhance reuse, and amount of top-down, pre-work, versus bottom up incremental reengineering. Particularly important is how it encourages or enforces use of these assets, how it invests in the people, process and technology to support the reuse program, and how it structures and manages the organization to provide, support and utilize the assets. Topics covered include: Business and economic issues; reuse experience; flavors of reuse; architecture, components, frameworks and product lines; reuse process and design methods, domain engineering; reuse governance and organization; and technology and tools such as templates, aspects, generators and repositories.

Attendee background

Prerequisites: This tutorial is geared towards managers, architects and senior developers who have some software engineering, programming and modeling experience, and who are eager to establish or refine an asset reuse program.

Format

Lecture and interactive discussion

Presenter

Martin Griss is one of the world's leading authorities on software reuse. He spent nearly two decades as Principal Laboratory Scientist and Laboratory Director at Hewlett-Packard Laboratories. Known as HP's "Reuse Rabbi," he created and led a corporate-wide software reuse program. His research has covered software reuse processes and tools, software engineering tools and methods, and software agents. He is co-author of "Software Reuse: Architecture, Process and Organization for Business Success," and author of over 60 book chapters, papers, columns and reports. He is an Adjunct Professor of Computer Science at the University of California at Santa Cruz, a consultant, and member of Flashline's Software Development Productivity Council.

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.

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.

47 Enterprise Application Integration with J2EE and .NET

Wednesday, 29 October – 13:30-17:00 Afternoon

Ian Gorton, Pacific Northwest National Laboratory, ian.gorton@pnl.gov
Anna Liu, Microsoft Australia, annali@microsoft.com

Creating enterprise-scale information systems poses many challenges, as such systems require integrating multiple (legacy) applications in such a way as to streamline and automate internal business processes and provide web-enabled business functions. The underlying architectures for such systems are embodied in a range of diverse products known as Enterprise Application Integration (EAI) technologies.

This tutorial introduces EAI. It highlights some of the major issues in EAI technology selection, application design, and deployment. It introduces service-oriented architectures as a means of EAI, and presents some common architecture patterns for accomplishing EAI using J2EE and .NET. J2EE components covered will include the Java Messaging Service, Java Connector Architecture and supporting application server technology. In .NET, BizTalk, Web Services and various XML technologies will be described and illustrated. We will conclude with a detailed comparison of the strengths and weaknesses of J2EE and .NET technologies for EAI.

Attendee background

Prerequisites: A solid understanding of object-oriented programming languages, such as Java, C++, or C#. Familiarity with the key features of distributed component technologies and enterprise platforms (e.g., J2EE, .NET) is useful but not required.

Format

Lecture and demonstrations

Presenters

Ian Gorton is chief architect in information sciences and engineering at the US Department of Energy's Pacific Northwest National Laboratory. His research interests include software architectures, particularly large-scale, high-performance information systems that use commercial off-the-shelf (COTS) middleware technologies. Dr. Gorton received a PhD in Computer Science from Sheffield Hallam University.

Anna Liu is an enterprise architect with Microsoft Australia. Her research interests include software architectures, patterns and best practices, and COTS software-evaluation and acquisition methods. Dr. Liu holds a BEng (with honors) and a PhD in computer engineering from the University of New South Wales, Australia.

49 Extending Enterprise Systems with Mobile/Wireless Applications

Wednesday, 29 October – 13:30-17:00 Afternoon

James White, Fourth Generation, Inc., jpwhite_mn@yahoo.com

Many organizations are adding mobile and wireless capabilities to their IT infrastructure. This tutorial explores technologies, designs and issues associated with the development of mobile and wireless software applications. In this tutorial, we explore how to leverage and reuse existing object-oriented system code for mobile and wireless applications. We also identify the pros/cons and development issues associated with various software application solutions, including Java, .NET, Wireless Application Protocol (WAP), and Brew. We examine the device market and its impact on software development. Finally, we discuss what makes for good and bad mobile/wireless software. Not unlike enterprise software, mobile/wireless software solutions must be appropriately designed. Some of the design and architecture issues are shared with those of bigger object-oriented applications. Other issues, especially around user interface and database synchronization, require special consideration. This tutorial exposes the mobile/wireless software architecture and design issues and potential solutions.

Attendee background

This tutorial is targeted to those individuals exploring mobile/wireless software application development.

Prerequisites: Participants should have some familiarity with the basic concepts of software development and object-oriented programming.

Format

Lecture, examples, and demonstrations

Presenter

James White is Wireless Practice Manager and Senior Consultant for Fourth Generation, Inc. based in St. Paul, MN. He is the co-author of "Java 2 Micro Edition" from Manning Publications and has written several articles on mobile/wireless computing, Java and object-oriented topics. Jim also finds time to speak frequently at industry conferences and spoke about J2ME at last year's JavaOne conference.

50 Understanding Circa-2003 XML Technologies

Wednesday, 29 October – 13:30-17:00 Afternoon

Don Box, Microsoft Corporation, dbox@microsoft.com

XML has grown out of the world of document management to become a broadly applicable technology that has impact on storage, messaging, and programming languages. This tutorial will look at the current landscape of XML technologies that are used to transmit, traverse, and transform XML-based information, with an emphasis on how these technologies impact current programming environments. Topics to be discussed include:

  • The XML Data Model(s)
  • Traversal: Imperative vs. Declarative
  • Transformation and Projection: XSLT and XML Query
  • Datatypes in XML: XML Schema Part II
  • Structural types in XML: XML Schema Part 1, Relax NG
  • XML Messaging: SOAP
  • Behavioral typing in XML: Web Services
  • Nominal typing in XML: RDF and WS-Policy

Attendee background

Attendees should have a basic familiarity with two or more type systems used in modern programming environments.

Format

Lecture

Presenter

Don Box is an architect on the XML Messaging team at Microsoft, where he works on defining and implementing the web service protocol stack. Don co-created the Simple Object Access Protocol (SOAP) and has helped develop SOAP-based technologies such as WS-Policy, WS-Reliable Messaging and WS-Addressing. Don has written several books on component technologies for Addison Wesley, beginning with "Essential COM," and most recently, "Essential .NET."

55 J2EE in Practice: Architectural Variations in the Context of Enterprise Systems

Thursday, 30 October – 8:30-12:00 Morning

Markus Völter, independent consultant, voelter@acm.org
Arne Koschel, IONA Technologies GmbH, arne.koschel@iona.com

J2EE serves as a reference architecture for enterprise applications. It has gained widespread use over the past few years. For each part of a multi-tier enterprise application, J2EE provides both an implementation technology and a blueprint of how it should be used.

Unfortunately, it is not always easy determine which J2EE technology to use in a given context, or how to use it. This tutorial explores different architectural alternatives available to developers when working with J2EE and describes when it is and is not appropriate to use each one. These guidelines are taken from experiences using J2EE for real-world, mission-critical applications.

Attendee background

Prerequisites: Attendees should have some experience with using J2EE and possess a basic understanding of what the different constituents of J2EE are used for.

Format

Lecture and discussion

Presenters

Markus Völter works as a freelance consultant for 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 - Component Infrastructures illustrated with EJB."

Over the last couple of years, Markus has architected, coached and implemented on several J2EE systems in various domains (banking, diagnostics, automotive) and on various scales (ranging from 10 developers and 400 concurrent users up to 120 developers and 50,000 users).

Dr. Arne Koschel works world-wide as Technical Product Manager and Product Specialist for IONA's Orbix Application Server Platform (ASP). Previously, he worked as independent Senior Object Technology Consultant and Enterprise Software-Architect with assignments throughout Europe and the United States. One of his major involvements (system architecture) for an Online Brokerage Application was selected as the major JavaOne 2001 J2EE customer success story. He is a regular speaker at conferences world-wide and author of many publications. He also cooperates with Universities, where he teaches courses in the areas of middleware and active databases.

56 Model-Driven Architecture

Thursday, 30 October – 8:30-12:00 Morning

Krzysztof Czarnecki, University of Waterloo, czarnecki@acm.org
Petter Graff, Inferdata Corporation, petter@inferdata.com

Today, application development remains a laborious process, with relatively little reuse or automation. Application programmers must manually map their high-level analysis models to target platform architectures, such as J2EE and .NET, and eventually, to code. Rather than focusing on the problem domain, they have to deal with the complex details of the target platforms. The analysis and design models - being just additional documentation artifacts - are often not properly maintained in the face of approaching deadlines. This makes the applications hard to evolve later. Retargeting an application to a new platform is almost as difficult as writing it from scratch. Model-Driven Architecture (MDA) is a framework for model-based development being standardized by the Object Management Group (OMG) that addresses these problems. In MDA, models are the primary source of an application. All other artifacts, such as code, tests, and documentation, are (mostly) automatically derived from models.

In this tutorial, we will take a critical look at the promises made by MDA and clearly distinguish what is possible today from the visions of tomorrow. After explaining basic MDA concepts, such as metamodeling and model transformations, we'll discuss tool requirements and review some existing MDA tools. We'll round up the tutorial with a demonstration of generating a complete J2EE and .NET application from the same high-level UML model.

Attendee background

Prerequisites: Attendees should have basic knowledge of UML.

Format

Lectures and demonstrations

Presenters

Dr. Krzysztof Czarnecki is an Assistant Professor at the University of Waterloo, Canada. Before coming to Waterloo, he spent 8 years at DaimlerChrysler Research working on the practical applications of generative programming (GP). He is co-author of the book "Generative Programming" (Addison-Wesley, 2000), which is regarded as seminal work of the area and is used as a graduate text at universities around the world. He is General Chair of the 2003 International Conference on Generative Programming and Component Engineering (GPCE). His current research focuses on realizing the synergies between GP and model-driven architectures.

Petter Graff is Vice President of InferData Corporation. He has developed object-oriented systems for more than 20 years. At InferData, his focus is in object-oriented component development, software architectures and advanced implementation techniques for enterprise applications. He created one of the first model transformation tools (MCC) and is currently responsible for the development of InferData's next generation agent-based model transformation tool. Petter is also coauthoring an upcoming book on Model Driven Development (estimated to be published fall 2003).