Sunday, 26 October

8:30-17:00 Full day

Tutorial 15 Judging Use Case Quality: Patterns for Writing Effective Use Cases
Tutorial 16: Concepts of Object-Oriented Programming
Tutorial 17 Programmer's Dozen: Thirteen Recommendations for Refactoring, Repairing, and Regaining Control of Your Code
Tutorial 18: An Introduction to Software Product Lines
Tutorial 19 Automated Software Testing: Hands On and Interactive!
Workshop 2: Are Agile Methodologies Really Different?
Workshop 6: Second International Workshop on Agent-oriented methodologies
Workshop 7: Process Engineering for Object-Oriented and Component-Based Development
Workshop 9: The 3rd OOPSLA Workshop on Domain-Specific Modeling
Workshop 11: Patterns for Retrospectives
Workshop 12: Second "Killer Examples" for Design Patterns and ObjectsFirst Workshop
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
Workshop 23: Open-Source in an Industrial Context
Workshop 24: Middleware Benchmarking
DesignFest®:

8:30-12:00 Morning

Tutorial 1: Scrum and Agile Process 101
Tutorial 2: Introduction to Concurrent Programming in Java
Tutorial 3: Domain Analysis for Product-Line Architectures
Tutorial 4: Introduction to Aspect-Oriented Programming with AspectJ
Tutorial 5: Evolutionary Design
Tutorial 6: Eclipse Extensions—Making the Connections
Tutorial 7 Programming Internet-Scale Distributed Applications in the 21st Century: BPEL and Beyond
Workshop 17: Extreme Programming Practices in the First CS Courses

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 11 Performance Solutions: Solving Performance Problems Quickly and Effectively
Tutorial 12 Successful Web Services and Service-Oriented Architectures: Beyond the Hype
Tutorial 13: Large-Scale Agile Software Development
Tutorial 14: An Introduction to the Common Language Infrastructure (CLI)
Workshop 20: Toward EduPLoP
DesignFest®:

17:30-20:30

Special Event: eclipse Technology Exchange (eTX), hosted by IBM

15 Judging Use Case Quality: Patterns for Writing Effective Use Cases

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

Steve Adolph, WSA Consulting Inc., steve@wsaconsulting.com
Paul Bramble, Emperative, Inc., Pbram47077@aol.com

Use cases are a wonderfully simple concept: describe a system's functional requirements by telling stories about how its actors use it. However, developers are discovering that writing effective use cases is more difficult than they had anticipated. Use case writers frequently must deal with difficult questions, such as:

  • What should be the scope of a use case?
  • How long should a use case be?
  • What level of detail should a use case express?
  • What expertise is required in the use case writing team?
  • How do we provide different levels of detail for different people?
  • Where do I put the requirements for the external interfaces and stored data?
  • Why am I doing this in the first place?

Usually, the answers to these questions is prefixed with an unsatisfying "Well, it depends."

An understanding of basic principles is not enough. Developers need a source of objective criteria to judge use case quality and effectiveness. This tutorial helps fill a critical information gap by presenting a pattern language that provides simple, elegant, and proven solutions to common problems in use case development. It captures the knowledge and experience of successful use case developers in a way that it can be easily used by others, and serves as the basis of a vocabulary describing the properties of quality use cases. As such, these patterns facilitate the development of original use cases and provide a diagnostic tool for evaluating existing ones.

Attendee background

Prerequisites: Attendees must have experience in using or preparing use cases, and be familiar with basic use case concepts.

Format

Interactive lectures and hands-on exercises, plus question-and-answer session

Presenters

Steve Adolph is a senior consultant with WSA Consulting Inc., where he specializes in software process improvement. He has twenty years of industrial experience developing software and managing software development projects in the telecommunications, railway signaling, and graphic arts industry. An exciting and enthusiastic speaker, Mr. Adolph has spoken at numerous seminars and workshops on software project management, object-oriented analysis and design, and patterns. He is co-author of the book "Patterns for Writing Effective Use Cases."

Paul Bramble is a Senior Software Engineer with Emperative, Inc., specializing in object-oriented software development and distributed systems. He has been developing software in the telecommunication, avionics, and computer manufacturing industries for over 20 years. Paul has been using and researching use cases since 1994, and co-authored the book "Patterns for Writing Effective Use Cases." He has given several presentations on use cases at the industrial and university levels, including at OOPSLA events.

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

17 Programmer's Dozen: Thirteen Recommendations for Refactoring, Repairing, and Regaining Control of Your Code

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

Kevlin Henney, Curbralan Limited, kevlin@curbralan.com

There is no shortage of technical wisdom on how to develop clear and robust code, so why is cryptic code and the corresponding look of puzzlement on a programmer's face such a common sight? Many companies and developers want to use state-of-the-art development practices, but seem swamped and bemused by how much state there really is to that art.

The tutorial offers a concrete, thirteen-point list of recommendations (zero through twelve) that can be applied immediately to reduce code size and complexity, acting as both guidelines for new code and indicators for refactoring. The short list has no ambition to be all that you needed to know about design but were afraid to ask, but it does offer an easily learned and easily practiced set of guidelines that offer the greatest immediate return on investment--the most bang for your buck or oomph for your euro.

Attendee background

This tutorial is targeted at people who write code for a living, typically using a curly-bracket language (C++, C#, Java, etc.) and are looking for that extra edge that allows them to keep their code live and clean.

Format

Lecture

Presenter

Kevlin Henney is an independent consultant and trainer. The focus of his work is in programming languages, object orientation, component-based development, 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.

18 An Introduction to Software Product Lines

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

Linda Northrop, Software Engineering Institute, lmn@sei.cmu.edu
Paul Clements, Software Engineering Institute, clements@sei.cmu.edu

Software product lines have emerged as a new and very important software development paradigm. A software product line is a set of software-intensive systems sharing a common, managed set of features, and that are developed in a disciplined fashion using a common set of core assets. Organizations developing their family of products as a software product line are experiencing order-of-magnitude improvements in cost, time to market, staff productivity, and quality of the deployed products. This tutorial covers the basic concepts of software product lines, the essential software engineering and management practices, and product line practice patterns that let an organization apply the practices in a way best suited to their individual needs. The concepts are illustrated with one or more detailed case studies of actual organizations' experiences with the software product line approach. The tutorial contents are based on the book "Software Product Lines: Practices and Patterns."

Attendee background

Prerequisites: Participants should have experience in designing and developing software-intensive systems and some familiarity with modern software engineering concepts and management practices.

Format

Lecture (65%) with discussion (20%) and short exercises (15%)

Presenters

Linda Northrop is currently director of the Product Line Systems Program at the Software Engineering Institute (SEI). She is co-author of the book, "Software Product Lines: Practices and Patterns." She received the 2001 Carnegie Science Center Award for Excellence in Information technology, was a keynote speaker at ICSE 2001 and AOSD 2002, OOPSLA Program Chair in 1999, OOPSLA Conference Chair in 2001, and the Conference Chair of the first and second international Software Product Line Conference (SPLC1 and SPLC2). She chaired the first Software Product Line Conference and is the current OOPSLA Steering Committee Chair.

Paul C. Clements is a Senior Member of the Technical Staff at Carnegie Mellon University's Software Engineering Institute. He is co-author of four books on architecture and product lines: "Software Product Lines: Practices and Patterns," "Software Architecture in Practice," "Evaluating Software Architectures: Methods and Case Studies," and "Documenting Software Architectures: Views and Beyond."

19 Automated Software Testing: Hands On and Interactive!

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

Gerard Meszaros, ClearStream Consulting, gerard.meszaros@acm.org
Ralph Bohnet, ClearStream Consulting, ralph@clrstream.com

This tutorial takes the "extreme" out of Extreme Programming. It brings the expertise acquired by the agile software development community to mainstream software developers working on all kinds of projects. The Extreme Programming community has shown the value of writing automated software unit and acceptance tests for increasing quality, reducing development cost and improving agility. Now that we know this is possible, how can we apply these lessons to more traditional software projects? And if you are an XP developer, how can you improve the way you write tests?

The XUnit family of testing frameworks (including JUnit, SUnit, NUnit, VbUnit, etc.) provide an important first step in software test automation. But test automation is much more than just knowing how to program a test in XUnit. The neophyte test-writer is faced with a deluge of questions and issues; e.g.,

  • What should I be testing?
  • How many tests are enough?
  • What should I focus on while writing my tests?
  • How do I test my tests?
  • How can I make my tests more understandable?
  • How do my tests relate to use cases?
  • How can I make my software easier to test?

This tutorial addresses these and many other questions.

Attendee background

This tutorial is intended for professional software developers who would like to learn how to test their software more effectively.

Prerequisites: Participants must be familiar with the object-oriented software development paradigm, and be fluent in one or more object-oriented languages. Familiarity with Java or C# is useful, but not required. Familiarity with a unit testing framework, such as JUnit, is preferable.

Format

Lecture and hands-on exercises

Presenters

Gerard built his first unit testing framework in 1996 and has been doing automated unit testing ever since. Along the way, he has become an expert in refactoring of software, refactoring of tests, and design for testability. Gerard has applied automated unit and acceptance testing on projects ranging from full-on eXtreme Programming to traditional waterfall development. He has presented successful tutorials at the past three OOPSLAs, has organized workshops at four previous OOPSLAs, and has presented papers on developing and testing object oriented software frameworks at two previous OOPSLAs as well as XP2001 and XP2002.

Ralph Bohnet is a senior consultant and trainer with Clearstream Consulting and has been doing agile development since 2000. He is an avid advocate of automated testing and Test First Development. Over the past 13 years of IT experience, he has acted as team leader, mentor, business analyst, OO developer, and instructor. He is currently the team lead of a testing team for a national Railway company. Ralph has been the president of Calgary Java Users Group for the past 4 years.

2 Are Agile Methodologies Really Different?

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

Jens Coldewey, Coldewey Consulting, jens_coldewey@acm.org
Pete McBreen, McBreen Consulting, pete@mcbreen.ab.ca
Mary Poppendieck, Poppendieck LLC, mary@poppendieck.com

With Adaptive Software Development, Crystal, Extreme Programming, Feature Driven Development, Lean Development, and Scrum the ecosystem of agile methods seems to stabilize. Though they all use different metaphors and approaches to software development, their hands-on results are so similar that readers may ask themselves, whether they are really different methodologies. Practitioners have had the best results combining elements of different agile methodologies — a possibility that defines a common species in biology.

This sequel to last year's OOPSLA workshop "Commonalities of Agile Methodologies" explores this question in depth in a highly interactive setting. It may work on questions like "What is different anyhow and why?", "What forces drive particular solutions?", or "How does a solution deal with limitations?".

http://www.coldewey.com/publikationen/conferences/oopsla2003/differences.html

6 Second International Workshop on Agent-oriented methodologies

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

Paolo Bresciani, ITC-Irst (Italy), brescian@itc.it
John Debenham, University of Technology, Sydney (Australia), debenham@it.uts.edu.au
Paolo Giorgini, University of Trento (Italy), pgiorgio@science.unitn.it
Ian Gorton, Pacific Northwest National Laboratory (USA), ian.gorton@pnl.gov

Following the success of object technology, the next advance is likely to be the introduction, adoption and widespread use of agent technology for business applications. Agents, building as they do in part on objects, require careful design. Appropriate methodologies for constructing agent-oriented systems may rely to some degree on OO methodologies, but their distinct autonomy of an agent means that these agent-oriented processes cannot be as deterministic as they have been in object-oriented developments. Support for emergent processes is required as well as further modifications to existing OO processes.

The overall goal of the workshop is to consolidate a research agenda for the next five years that will enable agent-oriented methodologies to become of "commercial strength" and to be widely adopted by industry.

http://www.open.org.au/Conferences/oopsla2003/AO.html

7 Process Engineering for Object-Oriented and Component-Based Development

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

Don Firesmith, SEI (USA), opfwebsite@hotmail.com
Cesar Gonzalez-Perez, University of Technology, Sydney (Australia), cesargon@it.uts.edu.au
Brian Henderson-Sellers, University of Technology, Sydney (Australia), brian@it.uts.edu.au
Pavel Hruby, Microsoft Business Solutions (Denmark), phruby@acm.org
Dilip Patel, South Bank University (UK), dilip@vax.sbu.ac.uk
Dan Rawsthorne, Net Objectives (USA), DrDan@NetObjectives.com
Bernhard Rumpe, Munich University of Technology (Germany), rumpe@in.tum.de
Magdy Serour, University of Technology, Sydney (Australia), magdy@serour.com
Hadar Ziv, eBuilt Inc., (USA), ziv@ics.uci.edu

During the last decade, Object-Oriented/Component Based Development has gained a wide acceptance from both academics and practitioners as the current optimal technology for software development. This has led to the creation of a plethora of OO methodologies and, more recently, OO processes. Many attempt to provide a "one size fits all" process.

An alternative that we explore in this workshop is to construct and/or tailor a process specifically for the organization by use of the technique of process engineering. While the creation of process components is reasonably mature, the guidelines to help organizations construct their own process from these process components are little understood. The workshop aims to create concrete advice to organizations on process construction and process tailoring. This will require interchange of ideas and experiences between researchers and practitioners.

http://www.open.org.au/Conferences/oopsla2003/PE.html

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/

11 Patterns for Retrospectives

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

Linda Rising, independent consultant, risingl@acm.org
Mary Lynn Manns, University of North Carolina at Asheville, manns@unca.edu

The theme of this workshop is patterns for retrospectives. Retrospectives are important, not only for object technology, but for any human activity: to provide time for reflection, to improve on performance, and to increase our understanding of the task at hand. The Principles Behind the Agile Manifesto state that, "At regular intervals, the team reflects on how to become more effective, then tunes and adjusts its behavior accordingly." There have been articles and an excellent book (Norm Kerth's Project Retrospectives) written on this topic but as is the case for many domains, experts know much that novices do not. We believe that documenting expertise in patterns is an excellent way to share knowledge.

The goal of this workshop is to begin documenting patterns for retrospectives and looking for a pattern language structure.

http://www.unca.edu/~manns/retropatterns.html

12 Second "Killer Examples" for Design Patterns and ObjectsFirst Workshop

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

Carl Alphonce, University at Buffalo, SUNY, alphonce@cse.buffalo.edu
Dung Nguyen, Rice University, dxnguyen@cs.rice.edu
Philip Ventura, University at Buffalo, SUNY, pventura@cse.buffalo.edu
Michael Wick, University of Wisconsin, Eau Claire, wickmr@uwec.edu
Stephen Wong, Rice University, swong@cs.rice.edu

According to the Jargon File a "killer app" is an "application that actually makes a sustaining market for a promising but under-utilized technology." A "killer example" provides clear and compelling motivation for a design pattern or design principles. An example is "killer" if it compels someone to spontaneously "buy-in" to that design pattern or technique.

"Killer examples" are important pedagogically because they get students on-board and excited about design in general and design patterns in particular. They are useful to convince peers or employees, not familiar with object-oriented design, that design patterns are central to good object-oriented practices and that they are not an esoteric topic that is best left to expert.

The workshop's goal is to bring together educators and developers who have "killer examples" to share. Pre-workshop activities encourage interaction and refinement of examples prior to the workshop.

http://www.cse.buffalo.edu/~alphonce/KillerExamples

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

23 Open-Source in an Industrial Context

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

Manfred Broy, Technische Universität München, broy@in.tum.de
Thomas Wieland, University of Applied Sciences Coburg, thomas@drwieland.de
Marc Sihling, 4Soft GmbH, sihling@in.tum.de

Open-Source software development moved into the focus of common interest a couple of years ago and by now, software engineers learned a lot about the dos and don'ts which often prove beneficial even for industrial software development projects. However, there are many more ways in which industrial software development can benefit from open-source communities — and vice versa.

In this workshop, we will elaborate on different aspects that help to establish this mutual benefit.

http://osic.in.tum.de/

24 Middleware Benchmarking

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

Paul Brebner, CSIRO Mathematical and Information Sciences, Australia, paul.brebner@csiro.au
Emmanuel Cecchet, INRIA Rhone-Alpes, France, emmanuel.cecchet@inrialpes.fr
Julie Marguerite, ObjectWeb Consorcium, France, julie.marguerite@inrialpes.fr
Petr Tuma, Charles University, Czech Republic, petr.tuma@mff.cuni.cz

The goal of the workshop is to help advance the current practice of gathering performance characteristics of middleware implementations through benchmarking. The workshop will serve as a meeting point between middleware developers and middleware users as two representative groups that are typically involved in middleware benchmarking but tend to have different requirements. Positions are solicited especially from people with previous or impending benchmarking experience.

The participants of the workshop will identify requirements and obstacles of middleware benchmarking and form a position on issues such as designing a framework that would allow the design, running and evaluating a diverse range of benchmarks over a diverse range of middleware, designing benchmark criteria that would allow for a meaningful comparison of results collected over different platforms, designing a framework suitable for regular regression testing, or providing means to verify the benchmarking results and their applicability to specific usage situations.

Keywords: middleware, benchmarking, performance evaluation

http://nenya.ms.mff.cuni.cz/projects/corba/oopsla-workshop

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

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

Tuesday, 28 October – 10:30-17:00

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

1 Scrum and Agile Process 101

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

Ken Schwaber, Agile Alliance, ken.schwaber@verizon.net

Agile development processes are different. They increase productivity, and they bring focus and pleasure back to software development. As they move from early adopters to the mainstream, practitioners and researchers require an understanding of their principles and operation. This tutorial explains the underlying theory and practices of all agile processes, and then explains how they are implemented in Scrum. A case study is presented that provides the rules and feel for the various Scrum practices. Then the new management practices and roles demanded by agile processes are explored. To wrap up, various techniques for scaling agile processes to any type of project are presented and examples provided.

Attendee background

Prerequisites: Attendees must understand software development, as demonstrated by participating in development projects.

Format

Lecture

Presenter

Ken Schwaber is Chair of the Agile Alliance. He is one of the developers of the Scrum agile process and is an author of the Agile Manifesto. He has given presentations at numerous conferences and user groups, and is author of "Agile Software Development with Scrum" with Mike Beedle. Ken has developed, managed and consulted about software development for over 30 years.

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

3 Domain Analysis for Product-Line Architectures

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

Neil Harrison, Avaya Labs Research, nbharrison@avaya.com
Frank Buschmann, Siemens AG, Corporate Technology, Frank.Buschmann@siemens.com

Product-line architectures promise better productivity and less maintenance costs for families of related software systems. A strong product-line architecture is one of the keys to a successful deployment of both product lines and any system destined to go through multiple releases. However, specifying high-quality product-line architectures is a surprisingly difficult task.

Commonality and variability analysis is a powerful domain analysis tool for the specification of product lines. It can help designers produce systems that are robust in the face of change, and that can be easily customized. Additionally, it feeds naturally into OO design. This combination provides a proactive, systematic approach to accomodating changes in software.

This tutorial introduces commonality and variability analysis in a real-world setting. Topics include: underlying principles, methodology, and synthesis with OO design. By the end of the tutorial, you will understand how to use commonality and variability analysis in your OO projects to specify a stable, yet flexible, software architecture.

Attendee background

This tutorial is aimed at architects and designers of systems that have many variations, such as product families and systems with multiple releases.

Prerequisites: Attendees should have solid background in OO principles, and some OO design experience. Experience in specification or analysis is helpful but not required.

Format

Lecture with exercises

Presenters

Neil Harrison is a researcher at Avaya Labs, where he consults with software projects in architecture, process, organizations, estimation, and product line engineering. He has been involved in software patterns since 1994. He has organized pattern conferences and has taught many courses on patterns. He is a member of the Hillside Group board of directors. He has published patterns and chapters in pattern books, and was lead editor of Pattern Languages of Program Design, Volume 4.

Frank Buschmann is senior principal engineer at Siemens Corporate Technology in Munich, Germany. His interests include Object Technology, Software Architecture, and Patterns. Frank has been involved in many software development projects. He is leading Siemens' software architecture 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".

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.

5 Evolutionary Design

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

Joshua Kerievsky, Extreme Programmer and Coach, Industrial Logic, Inc., joshua@industriallogic.com
Russ Rufer, Extreme Programmer and Coach, Industrial Logic, Inc., russ@industriallogic.com

While Test-Driven Development and Refactoring are extremely useful software development practices, they are insufficient for evolving great designs. What's missing are the thinking and coding practices that real-world evolutionary designers use to evolve top-notch designs effectively. Such practices include critical learning that results from early end-to-end system development, significant time savings obtained by determining what doesn't need to be automated, eye-opening design simplicity achieved by automating failing acceptance tests before writing code, important design progress that results, paradoxically, from undoing previous design work and more.

This tutorial takes the mystery out of Evolutionary Design by naming and explaining what its thinking and coding practices are and how to implement them. You'll be challenged to solve Evolutionary Design exercises and you'll experience how a game of blackjack evolves from a first failing UI test to a functioning version of the game. Along the way you'll learn how not to evolve blackjack, you'll study micro-snapshots of the evolution-in-progress and you'll understand what the evolution of a game teaches us about Evolutionary Design on real-world projects.

Attendee background

Prerequisites: Participants should be able to read Java™ code to get the most out of the session. No background is required in Agile Development, Refactoring, or Test-Driven Design.

Format

Interactive lecture and programming demonstration

Presenters

Joshua Kerievsky has been programming professionally since 1987, and is the founder of Industrial Logic (http://industriallogic.com), a company specializing in Extreme Programming (XP). Since 1999, Joshua has been coaching and programming on small, large and distributed XP projects and teaching XP to people throughout the world. He is the author of numerous XP and patterns-based articles, simulations and games, including the forthcoming book, Refactoring to Patterns (http://industriallogic.com/xp/refactoring/).

Russ Rufer has been building software systems for 15 years. His wide-ranging experience includes desktop applications, embedded firmware, telecommunications, networking, satellite simulation, and productivity tools. Russ leads weekly meetings of the Silicon Valley Patterns Group, which he founded in 1998 (http://pentad.com/SiliconValleyPatterns.html) and regularly organizes pre-publication review teams to provide feedback on new literature from the software patterns and agile development communities. Russ has worked with Industrial Logic for several years. He divides his time between pure development, coaching and leading workshops on Extreme Programming, Testing, Refactoring and Patterns.

6 Eclipse Extensions—Making the Connections

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

Kai-Uwe Maetzel, IBM Research, OTI Labs, kai-uwe_maetzel@ch.ibm.com

Eclipse (http://www.eclipse.org) is an open-source platform for building tools for developers. The platform was designed from the ground-up with extensibility in mind. A scalable plug-in mechanism and a rich set of APIs enables developers to develop and explore new tools quickly, without having to start from scratch.

This tutorial illustrates the full plug-in development cycle by way of an example. You'll explore the Eclipse architecture and become familiar with the basic plug-in mechanism. With this knowledge, you'll write and debug your first plug-in using Eclipse's Plug-in and Java Development Environments. You'll also add extension points to your plug-in to enable others to extend it. You will then package your extensible plug-in as a Feature and publish it with the built-in Eclipse Update Mechanism. Finally, you'll set up and manage an Eclipse Update Site, a place for other Eclipse users to explore new features as well as finding upgrades.

During all these steps, you will learn the underlying Eclipse concepts and design ideas. You'll learn the rules you need to know to make your plug-ins good Eclipse citizens. In addition, you will receive many interesting insights on design challenges in large scale plug-in architectures.

Tutorial participants are invited to bring their laptops and deepen their understanding by implementing practical exercises.

Attendee background

This tutorial is targeted toward developers who are interested in writing their own Eclipse plug-in tools. Developers with an interest in large-scale plug-in architectures will also benefit from the insights into Eclipse.

Prerequisites: Experience with Java™ development is required.

Format

Lecture and exercises at the computer

Presenter

Kai is one of the original committers on the eclipse.org project. He is a member of the Eclipse architecture team and component lead of the Eclipse Text Infrastructure and Editor Components. He is also a member of the development team for the Eclipse Java Development Environment.

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.

17 Extreme Programming Practices in the First CS Courses

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

Joseph Bergin, Pace University, berginf@pace.edu
James Caristi, Valparaiso University, James.Caristi@valpo.edu
Daniel Steinberg, Dim Sum Thinking, Inc., DSteinberg@core.com

Most of the practices of Extreme Programming are beneficial to students in their computer science courses. But in order to teach students properly, pedagogical changes are needed as early as CS1. This workshop seeks participants who have significant ideas for changes that can be made in early computer science courses that involve integrating any of the practices of Extreme Programming or other agile methodologies.

Would-be participants should send in a short position paper outlining one or two ideas they have. During the workshop, participants will critically discuss the ideas that have been suggested and explore any new ones that arise. Participants will agree to allow their ideas to be shared via a web page to be posted in various CS educational resources repositories.

http://csis.pace.edu/~bergin/XPWorkshop

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.

11 Performance Solutions: Solving Performance Problems Quickly and Effectively

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

Connie U. Smith, Performance Engineering Services, cusmith@perfeng.com
Lloyd G. Williams, Software Engineering Research, boulderlgw@aol.com

If you've got performance problems, you need help to get out of trouble now. This tutorial is designed to provide you with basic knowledge that you can immediately apply to improve the performance of your software. It presents a practical approach to identifying sources of performance problems. Whether you are involved in new development or upgrading a legacy system, this tutorial will help you quickly and effectively achieve your goals for responsiveness and scalability without sacrificing other quality objectives, such as reliability, modifiability, or security. We'll also introduce techniques that help you determine whether a legacy system is worth fixing or beyond repair.

Attendee background

Prerequisites: Attendees should be familiar with object-oriented development. No background or experience in software performance engineering is required.

Format

Lecture

Presenters

Dr. Connie U. Smith is Principal Consultant of the Performance Engineering Services Division of L&S Computer Technology, Inc. She specializes in applying performance prediction techniques to software, developing SPE tools, and teaching SPE seminars. She is the author of the original SPE book, "Performance Engineering of Software Systems." She is known for her seminal work in defining the field of SPE and integrating SPE into the development of new software systems.

Dr. Lloyd G. Williams, principal consultant at Software Engineering Research, is internationally recognized for his work in the development and evaluation of software architectures to meet quality objectives including performance, reliability, modifiability, and reusability.

Together, Drs. Smith and Williams have over 50 years of experience in software development. They have worked together for approximately 15 years to help clients design and implement software that meets performance objectives. They have published numerous technical papers and articles, and coauthored the book, "Performance Solutions: A Practical Guide to Creating Responsive, Scalable Software," published in Addison-Wesley's Object Technology Series in 2002.

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.

13 Large-Scale Agile Software Development

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

Ron Crocker, Motorola, ron@roncrocker.com

All of this XP and Agile Methods hype is wonderful, but how can people who work on large-scale software projects (i.e., projects with more than 100 people and longer than 1 year duration) take advantage of the benefits in quality, efficiency, and time promised by the hype?

That question is answered in this tutorial. We will go through an approach--one that has worked well in practice--that enables teams to collaborate in an agile way on large projects. This tutorial will cover the following topics:

  • Why large projects are indeed different
  • Why existing agile methods (XP, Scrum, ...) are insufficient to deal with large projects
  • A set of agile practices enabling agile multi-team collaboration
  • Experiences with the practices
  • How you can do something differently when you get back home

At the end of the session, you will leave the room either shaking your head saying, "I wish I could do that," or you will have definite plans to try these practices when you get back to work.

The material in this tutorial comes principally from the presenter's forthcoming book, "Large-Scale Agile Software Development," which may be available in time for OOPSLA.

Attendee background

This tutorial is geared towards practitioners, software or process engineers in development leadership roles, or someone with influence on such people.

Prerequisites: Experience developing large systems, and exposure to the attendant difficulties of doing so, is required. Knowledge of object technologies is not essential, but it is helpful.

Format

Lecture

Presenter

Ron Crocker is a Fellow of the Technical Staff in the Network and Advanced Technologies group of Motorola's Global Telecom Solutions Sector, where he has pioneered the application of advanced software technologies and processes in the development of next-generation cellular telecommunications systems. He is the author of the forthcoming Addison-Wesley book "Large-Scale Agile Software Development."

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.

20 Toward EduPLoP

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

Joseph Bergin, Pace University - Computer Science, berginf@pace.edu
Fred Grossman, Pace University - Information Systems, grossman@pace.edu
Jutta Eckstein, Objects in Action, jeckstein@acm.org
Eugene Wallingford, University of Northern Iowa, wallingf@cs.uni.edu

Software patterns have had a positive impact on how software is built and how organizations work. They have had relatively little impact on education, however. This workshop will bring together experienced educators and industrial trainers to investigate how this might be changed. There are many questions to be answered: Should students write patterns? Use Patterns? Should patterns inform how we teach? What we teach? What are the benefits and challenges of using and teaching patterns in education? What kinds of patterns are most effective: design patterns, elementary patterns, pedagogical patterns and organizational patterns?

This workshop will feature a range of presentation formats, including short presentations, exercise demos, and discussions. A major goal of the workshop will be to decide on the desirability and feasibility of holding a future EduPLoP, directed at educators and students.

http://csis.pace.edu/~bergin/towardEduPLoP

eclipse Technology Exchange (eTX), hosted by IBM

Sunday, 26 October – 17:30-20:30

Eclipse . . . plays well with others!

IBM invites you to attend a special reception and poster session on Sunday, October 26, 2003. Learn more about Eclipse, and meet some of the Eclipse Innovation Grant recipients who are using this technology in creative software, educational and research development projects.

The reception is open to all OOPSLA attendees.

Join the increasing number of developers and educators who belong to the Eclipse Community. What is Eclipse? Much more than just an IDE, Eclipse is an open source community as well as an open universal platform for tools integration. Check out http://www.eclipse.org