Monday, 27 October
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.
Prerequisites: Attendees must have basic experience with Java and any interactive development environment.
Lecture and demonstrations
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.
This tutorial is a short, quick-paced introduction to object-oriented analysis and design, based on practical project experience. It will provide you with the knowledge and skills to:
This tutorial is targeted to people who are new to objects and object-oriented concepts. It is intended for people who have had some exposure to objects but need more knowledge to be able to put all the pieces together.
Jill Aden has worked for 18 years with EDS as a Systems Architect and has worked with objects since 1993. She is a member of the OTUG group at the University of St. Thomas in St. Paul, MN and served as the Communications Chair at OOPSLA 2002. Ms. Aden is in the process of writing an object-oriented analysis and design book for undergraduate students. At EDS, she mentors, consults, and teaches object-oriented concepts internally and externally to clients.
Joseph Brennan is a System Architect with EDS, where he has worked for 18 years. He is a member of the Twin Cities Java User Group and has been working with objects for 10 years. Mr. Brennan is in the process of writing an object-oriented analysis and design book for undergraduate students. At EDS, Joseph mentors, consults, and teaches object-oriented development and concepts within EDS and externally to clients. Joseph is a Sun Certified Java Instructor and Java Developer.
Developing concurrent and networked object-oriented applications is hard; developing high-quality reusable components for these types of applications is even harder. The principles, methods, and skills required to develop reusable software cannot be learned by generalities. This tutorial, therefore, illustrates by example how to significantly simplify and enhance the development of communication software that effectively utilizes concurrency and distribution via the use of:
The tutorial examines patterns and framework solutions abstracted from production systems in domains including from telecommunications, avionics, online trading systems, medical systems, web servers, and real-time object request brokers to illustrate the key technical design and implementation issues. The material presented in this tutorial is based on the book "Pattern-Oriented Software Architecture: Patterns for Concurrent and Networked Objects," Wiley & Sons, 2000.
Prerequisites: Participants must be familiar with object-oriented development techniques (such as patterns, modularity, and information hiding), OO language features (such as classes, inheritance, dynamic binding, and parameterized types), systems programming concepts (such as process/thread management, synchronization, and IPC), and networking terminology (such as client/server architectures and TCP/IP).
Dr. Douglas C. Schmidt is a Professor in the Electrical Engineering and Computer Science department at Vanderbilt University. His research focuses on patterns, optimization techniques, and empirical analyses of object-oriented frameworks that facilitate the development of distributed real-time and embedded (DRE) middleware. Dr. Schmidt has over fifteen years of experience developing DRE middleware as the chief architect and developer of ACE and TAO, which are widely used, open-source middleware containing a rich set of components that implement patterns for DRE systems. Dr. Schmidt has also served as a Deputy Director and a Program Manager at DARPA, where he led the national R&D effort on DRE middleware.
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:
Model Driven Architecture (MDA) is an initiative by the OMG to leverage UML-based modeling techniques to insulate abstract software system specifications from implementation dependencies. The workshop focuses on generative techniques that can be used to realize MDA. We aim to bring together practitioners, researchers, academics, and students to discuss the state-of-the-art of generative techniques in the context of MDA. The OOPSLA'02 workshop on this topic was highly successful and led to the launch of the Generative Model Transformer (GMT) open source initiative.
Topics of interest include:
The goal is to share experience, consolidate successful techniques, and identify the most promising application areas and open issues for future work.
Agile Contracts. Are these two words an oxymoron? Contracts have played a very important role in the business of software development; in fact, much of this work is in fact done 'under contract'. Organizations adopting agile methodologies are finding it hard to write contracts for software development without compromising the core values and practices. The Agile Contracts workshop is your chance to help the agile community identify ways contracts can be structured and worded to support agile software development.
Come prepared to participate! Come and participate in the discussion about how to structure agile software development contracts and take away many great ideas, no matter which side of a software development contract you find yourself.
"I learned more from this workshop than from any other session," said one Agile Contracts Workshop participant at XP 2003. Use gaming theory to understand the motivations of contracting parties. Share examples of a contract structure, which had either good or bad effects on agile software development. Work with a small team to devise a contracting strategy, which supports agile software development.
Leave a Legacy. The good ideas generated in this workshop will be posted to the web for all to see.
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.
UML (Unified Modeling Language) has been widely accepted by the industry as the lingua franca for modeling object-oriented applications. In recent years, UML profiles such as the Common Warehouse Metamodel (CWM), the UML Profile for Enterprise Distributed Object Computing (EDOC) and the UML Profile for Enterprise Application Integration have defined specialized modeling languages for particular problems. The ISO Reference Model for Open Distributed Processing (RM-ODP) calls for systems to be designed with multiple viewpoints. These viewpoints represent different abstractions and might be implemented as different modeling languages for expression of the particular concepts and relationships relevant to the point of view. These languages should be integrated or otherwise reconciled to achieve a consistent overall system design.
The purpose of this workshop is to explore the characteristics of models of information systems that address areas of concern beyond the structure of programs, and to consider the implications of integrating such models to develop a comprehensive, consistent model of a system.
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.
Reengineering and evolution are important for long-lived software systems. Change and growth in the system's requirements and functionality occur in all kinds of systems — and it is especially critical to manage the evolution process in modern agile and extreme software processes. The management of change and growth may in fact become a daily activity, so a well defined set of techniques and tools for doing reengineering are critical to success.
This workshop picks up from the results of the OOPSLA '02 workshop "Tackling the Discovery Costs of Evolving Software Systems."
Participants will present and discuss encapsulation and reverse engineering techniques, impact of reengineering on software processes, organizational concerns, and experiences in managing software change "in the extreme".
Semantics underlie the fundamental problems that business stakeholders and system developers constantly cope with when integrating enterprise systems. Well-known issues, such as semantics description, expression of common semantics across systems and interoperability of data and processes, are amplified in the enterprise arena. Enterprise integration, although related to it, is not synonymous to technical systems integration. More complex forms of communication and coordination are required and encompass the multifaceted dimensions of the business (i.e., technical, organizational and human).
The importance of identifying ways to define, model and express semantics at a business level is highlighted by the growing importance of the application of ontologies to the development and re-engineering of enterprise systems. Also semantics is driving emerging technologies such as the semantic web, GRID systems and web services.
This workshop is aimed at bringing together researchers and practitioners with diverse cultural and professional backgrounds in order to discuss and analyze the different semantic issues and perspectives of enterprise integration.
Keywords: enterprise/systems integration, semantics, ontology, services.
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:
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:
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.
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/
The objective of this workshop is to have a detailed technical discussion on requirements for future virtual machines and advanced languages from an applications perspective.
Issues such as what features and their virtual machine implementations actually promote object reuse. What has worked in the past? Has the original design goals of the respective participants in their respective object architectures been met. What problems were encountered during the commercial deployment of their respective architectures? What do the participants see as the direction they believe that virtual machine technology will take in the near future, as well as over the long haul?
Web services and service-oriented architectures are promising technology. However, they are still fraught with problems and issues: operational issues, quality of service, functional and methodology related.
In this workshop we aim to identify real industry experiences (successes or failures) in designing and implementing web services based systems. And we look for research papers aiming at identifying and alleviating major bottlenecks and issues related to service-oriented architectures, web services and dynamically re-configurable architectures.
This workshop builds on the Object Oriented Web Services workshops in previous OOPSLA conferences and sets a slightly different direction, aimed at consolidating web services and service-oriented architecture best practices and patterns.
This tutorial gives an in-depth overview of the C# programming language, both as it currently exists and as it is planned to evolve in the near future. An emphasis will be placed on explaining design rationales, making the talk interesting for both programmers and language designers.
Prerequisites: Participants should have a good working knowledge of object-oriented programming. Previous experience with C# and .NET is not required.
Lecture and working code demonstrations
Anders Hejlsberg is a Distinguished Engineer in the Developer Division at Microsoft Corporation. He is the chief designer of the C# programming language and a key participant in the development of the .NET Framework. Before joining Microsoft in 1996, Anders was a Principal Engineer at Borland International. As one of the first employees of Borland, he was the original author of Turbo Pascal and later worked as the Chief Architect of the Delphi product line. Anders studied Engineering at the Technical University of Denmark.
This tutorial presents the issues facing modern high-performance garbage collectors and examines the approaches taken by state-of-the-art garbage collectors.
Participants will gain a deeper insight into the operation of modern, high-performance garbage collectors. The tutorial will enable participants to evaluate the benefits and costs of such garbage collection algorithms, to understand the implications for their code and to make informed choices between collectors.
Prerequisites: Participants must be experienced programmers familiar with basic garbage collection technology. Basic knowledge of OO implementation is useful but not essential.
Lecture, animations, and demonstrations
Richard Jones is a Senior Lecturer and Deputy Director of the Computing Laboratory at the University of Kent. He is the prime author of the book on Garbage Collection. His interests include programming languages and their implementation and visualisation, storage management and distributed systems. He is Coordinator of the UK Memory Management Network of researchers, a member of the Steering Committee of the International Symposium on Memory Management and was Programme Chair for ISMM'98. He has presented several tutorials at OOPSLA and ECOOP.
Eric Jul is a Professor at DIKU, the Dept. of Computer Science, University of Copenhagen where he leads research in distributed, heterogeneous computing. He is co-designer and principal implementer of the Emerald distributed object-oriented programming language. His interests include distributed, OO languages, operating systems support for such languages including distributed storage management (distributed shared memory and garbage collection) and object-oriented design and analysis. At previous ECOOP/OOPLSA conferences he has run a number of workshops and tutorials related to distributed computing and memory management. He was Programme Chair for ECOOP'98.
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.
Prerequisites: Sound knowledge of the pattern concept and the GoF patterns are required.
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.
The last decade or so has been one of technology churn. We've seen client/server, CORBA, J2EE, COM, .NET and a host of other enterprise platforms appear or fade from view, or both. Keeping up with resulting alphabet soup is a full time job, even without applications to ship.
But amongst all of this churn, some techniques stay relatively constant. So we've been trying to identify these common patterns and taking note of how we use the ideas from one technology and use similar, but not the same designs in others.
In this tutorial, we'll explore a number of these patterns. We will touch on various topics, including layering, business logic organization, database mapping, organizing a web interface and the allure of distributed objects.
The tutorial is based on the author's book, "Patterns of Enterprise Application Architecture."
Prerequisites: Participants must be familiar with the basics of object-oriented development in an enterprise setting.
Martin Fowler is the Chief Scientist of ThoughtWorks, a systems delivery and consulting firm. He has pioneered the use of object-oriented technology in enterprise applications and has written five books on software development.
XP advocates streamlining the requirements specification activity process, to the extent that conversations and automated tests replace thick, formal, and invariably incomplete/outdated requirements documents. The dials are turned to the maximum settings, resulting in maximum agility. There are most certainly situations where this approach is a perfect fit. But what about situations where this approach is not possible (e.g. distributed teams, safety critical systems, etc)? If we fiddle with the settings of some of the dials, will the end result still be agile?
This tutorial explores strategies for tuning the requirements process to optimize agility for a given set of project factors (e.g. team size, project complexity, project criticality, team knowledge and experience, stability and completeness of requirements, etc). Topics discussed include: What work products do we need to use? How much detail is required? How formal does the communication channel need to be? How formal does the notation need to be? What kinds of tools do we need to use? What is the impact of unexpected change?
This tutorial is targeted to developers, managers, analysts, and "customers."
Prerequisites: Knowledge of common requirements artifacts such as use cases and UML notation (use case diagrams, activity diagrams, state transition diagrams, class diagrams) is beneficial but not required. This tutorial focuses on the application of more general concepts and not the specifics on any one set of requirements artifacts.
This tutorial is extremely interactive (definitely not "death by PowerPoint"). Simulation exercises provide participants with first hand experience and rapid feedback on various approaches to requirements specification. Guided group discussions following each simulation enable the sharing of insights and facilitate a deep and lasting understanding of the underlying concepts.
Jennitta has been a senior consultant with ClearStream Consulting since 1994 as process mentor, OO developer, requirements analyst, business modeler, instructor, and retrospective facilitator. Jennitta has been a practitioner of XP since 2000 in a variety of capacities: developer, mentor, and writer/speaker ("Managing the Bootstrap Story," XP 2001, "Catalog of XP Project Smells," XP 2002, and "Framework XP," XP 2002). Jennitta is an experienced instructor; she has recently co-developed and delivered multiple sessions of a three-day course on automated testing for developers and a three-day workshop on agile requirements specification.
Gerard is Chief Scientist at ClearStream Consulting, where he leads teams applying agile software development techniques (such as eXtreme Programming) to help ClearStream's clients achieve faster and higher quality application development. He has presented successful tutorials at the past four OOPSLAs and has presented papers on automated testing and developing object oriented software frameworks at past XP and OOPSLA conferences.
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.
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.
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.
Static typing aids in earlier error detection, supports compiler optimizations, and provides information to programmers on the intended use of constructs. However, simple static-typing disciplines for object-oriented languages like C++ and Java are so restrictive that programmers are forced to bypass the type system with type casts. Other languages allow more freedom, but require run-time checking to pick up the type errors that their more permissive systems missed.
After surveying problems with existing type systems (illustrated by a series of sample programs), we explain contravariance and covariance issues in type systems, and suggest ways of improving the expressiveness of these systems while retaining static type safety. Constructs introduced include "MyType," "matching," and "F-bounded polymorphism." We include a brief discussion on how the type system and semantics ensure type safety. We apply the concepts in the tutorial to compare the strengths and weaknesses of proposals to extend Java to support genericity based on F-bounded polymorphism, "where" clauses, match-bounded polymorphism, and virtual types. In particular, we cover the advantages and disadvantages of the forthcoming extensions to Java (taken from GJ) to support parametric polymorphism.
Prerequisites: Attendees should be very comfortable with a class-based object-oriented programming languages. Ideally, the attendee should have sufficient experience with type systems as to be frustrated with their limitations.
Kim Bruce is Wells Professor of Computer Science at Williams College. He received his Ph.D. from the University of Wisconsin and has been a visiting professor or scientist at M.I.T., Stanford, and Princeton, among others. A researcher on the types and semantics of object-oriented languages, he has served twice on the OOPSLA program committee, on the program committee of POPL '03, and as chair of the organizing committee of the FOOL workshops on the Foundations of Object-Oriented Languages for many years. He has presented papers at the ECOOP, OOPSLA, and POPL conferences, and is the author of the book, "Foundations of Object-Oriented Languages: Types and Semantics," MIT Press, 2002.
Reflection can help to improve productivity by promoting the development of programs that are easily adapted to requirements changes. Reflection facilitates testing and problem determination by permitting the automation of more tedious tasks. In general, reflection improves the flexibility, extensibility, and reusability of code.
The Java programming language (version 1.4) contains a highly effective reflection facility. This tutorial explains the concept of reflection, the Java metaobjects (including both introspective and intercessional interfaces), the proxy class, and dynamic compilation and class loading. The limits of Java reflection are addressed in the context of what reflection is capable of in general. In addition, the tutorial demonstrates the efficacy of the Java reflection facility for solving practical problems. Such problems include: program/application testing, generation of code, inspection of code, and use of dynamic class loading in a framework for application extension. Finally, we will cover the performance impact of using reflection.
This tutorial is the basis of a book titled "Java Reflection" to be published by Manning Publications.
Prerequisites: Attendees must be competent Java programmers.
Dr. Ira R. Forman works for IBM in Austin. As a member of IBM's Object Technology Products Group, which produced the SOMobjects Toolkit, he worked on the SOM Metaclass Framework. From 1984 to 1991, he worked on distributed systems design in the MCC Software Technology Program. He started working in the area of object-oriented programming in 1982 at the ITT. Dr. Forman received his Ph.D. in Computer Science from the University of Maryland, where he studied under Harlan Mills. His specialties are object-oriented programming, distributed systems, and object composition. He is the coauthor of two books: "Interacting Processes: A Multiparty Approach to Coordinated Distributed Programming" and "Putting Metaclasses to Work: A New Dimension in Object-Oriented Programming."
Nate Forman works for Ticom Geomatics where he designs and programs application frameworks for their products. His specialties are patterns and object-oriented programming. Forman holds a MSE in Software Engineering from the University of Texas at Austin and a BS in Computer Science from the College of Engineering at Cornell University.
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.
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.
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."
Dealing with the complexity of large-scale systems can be a challenge for even the most experienced software designers and developers. Large software systems can contain millions of elements, which interact to achieve the system functionality. Managing and representing the complexity involved in the interaction of these elements is a difficult task.
This tutorial will help you manage this complexity through the use of industry-proven software architecture approaches, based on the UML and IEEE 1471 standards. We will introduce software architecture terminology and approaches, focusing on a set of UML viewpoints that represent the important aspects of a large-scale software architecture. These viewpoints include context, component, subsystems, process and deployment. These viewpoints leverage the recent IEEE 1471 standard for software architecture representations providing a description of the purpose, stakeholders, and techniques associated with each viewpoint.
The tutorial also presents other practical techniques essential to developing an effective software architecture. Topics covered in the tutorial include:
Prerequisites: Attendees must have a basic understanding of UML, have experience as a software developer, and an interest in software architecture. Experience on a large-scale software system is beneficial but not required.
Lecture and discussion
Jeff Garland has worked on many large-scale software projects over the past 16 years, and in many different domains, including telephone switching, industrial process control, satellite ground control, and financial systems. He has served as both the lead architect and a member of the architecture team on several of these projects. Mr. Garland holds a Master's degree in Computer Science from Arizona State University and a Bachelor of Science in Systems Engineering from the University of Arizona. He is currently President and Chief Technology Officer of CrystalClear Software. CrystalClear Software is a consulting firm that specializes in the development of software architectures for large-scale systems.
Richard Anthony has l7 years experience working on large-scale software development efforts. The systems are from application areas such as satellite and network operations systems, telephony base station control, manufacturing, and simulation. He has served in the role of chief software architect, design engineering technical lead, software design lead, software system engineer, and developer on projects in these application areas. Mr. Anthony holds Master's degrees in Computer Science and Mathematics, as well as a Bachelor's degree in Mathematics Education, all from the University of Wyoming. He is currently a Senior Software Architect at General Dynamics Decision Systems.
So you're a technical lead. You will have to combine many disparate skills to achieve that elusive goal, the successful team. Project management, people management, requirements management, as well as good design and implementation skills, are all core ingredients. This tutorial examines techniques and patterns for being a successful technical lead. Key areas covered include:
...and more. A recent project will be used to illustrate the application of the techniques "in the wild." During the tutorial, there will be time to share experiences, discuss problems and consider other solutions. Participants will leave with a comprehensive set of references.
Participants will be either new to technical leadership or already have been in a technical lead role for some time and wish to share experiences and learn some new techniques.
Lecture, group discussion, and copious real world examples
Andy Schneider wears consultant and architect hats for BJSS, a software services organisation. He has been involved in implementing, designing and leading projects utilising object-oriented technology since 1990. His primary interests are complex distributed systems, security and technical management. When wearing his consultant hat, he finds himself performing presentations and tutorials on a regular basis.
Large information systems need a domain model. Development teams know this, yet they often end up with little more than data schemas. This tutorial delves into how a team, developers and domain experts together, can engage in progressively deeper exploration of their problem domain while making that understanding tangible as a practical software design. This model is not just a diagram or an analysis artifact. It provides the very foundation of the design, the driving force of analysis, even the basis of the language spoken on the project.
The tutorial will focus on three topics:
The tutorial will include group reading and discussion of selected patterns from the book "Domain-Driven Design," Addison-Wesley 2003, and reenactments of domain modeling scenarios.
Prerequisites: Attendees must have a basic understanding of object-oriented modeling and the ability to read UML. Some involvement, past or present, in a complex software development project is helpful in seeing the applicability of the material, but is not essential. Familiarity with the practices of Agile Methods and/or Extreme Programming is helpful, but not essential.
Interactive reading/discussion session, and simulations of the activities and processes that go into making domain design decisions.
Eric Evans is a specialist in domain modeling and design in large business systems. Since the early 1990s, he has worked on many projects developing large business systems with objects and, since 1999, has been deeply involved in three projects committed to the Extreme Programming process (XP), and has trained teams in the Extreme Programming process. Out of this range of experiences have emerged the synthesis of principles and techniques shared in the book "Domain-Driven Design," Addison-Wesley 2003.
Ralph Johnson is a co-author of the now-legendary book, "Design Patterns" (Addison-Wesley, 1995). He is on the faculty of the Department of Computer Science at the University of Illinois. He is the leader of the UIUC patterns/Software Architecture Group and the coordinator of the senior projects program for the department. His professional interests cover nearly all things object-oriented, especially frameworks, patterns, business objects, Smalltalk, COM and refactoring.
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.
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.
Lecture and interactive discussion
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.
Some people consider use cases and agile development to be contradictory concepts, writing use cases as mere replacements for whatever requirements documents they were writing on their all-requirements-first, document-centric projects. Alistair Cockburn, one of the few people expert in both use cases and agile development, will review how to work with use cases on those other projects, where you choose to spend less time on documentation, do it later, need to save money, or plan on changing your mind along the way.
Part of the secret is in writing less, more clearly. The tutorial will include tips for structuring use cases to take less time to write, becoming both shorter and clearer, siphoning less time from project progress, and communicating crucial information more quickly. Part of the secret lies in knowing what parts to omit and when to omit them. The tutorial will include tips for shortcutting both the process and the use case structure for those projects that choose those tradeoffs. Not much can be said about tools, but what is known about setting up tools for agile use cases will be addressed. Along the way, the tutorial will review the fundamentals of both use cases and agile development, addressing particularly the basic structure and common misconceptions surrounding each. The presenter will allocate time within the session to answer arbitrary questions that the curious attendee might bring along.
This tutorial is intended for people who are curious about agile development, or those familiar with agile development and skeptical about adopting use cases.
Prerequisites: Some previous exposure to use cases is required. No special knowledge of agile development is needed.
Lecture and discussion
Dr. Cockburn is a highly-regarded instructor and is known as one of the premier experts on use cases as well as one of the authors of the Manifesto for Agile Software Development. His book "Writing Effective Use Cases" set the standard in the area. That and his "Agile Software Development" both received the Jolt Productivity book awards in 2001 and 2002, respectively. Dr. Cockburn has taught use case writing since 1994, and has also acted as consultant on project management, object-oriented design, and methodology to the Central Bank of Norway, the IBM Consulting Group, and the First Rand Bank of South Africa. Materials that support his workshops can be found at http://Alistair.Cockburn.us.
All full (and Tuesday one-day) conference registrants, along with the Tutorial-only registrants, are invited to attend the Welcome Reception. OOPSLA attendees are encouraged to view the OOPSLA 2003 Poster Session during the Welcome Reception. The Poster Session at the Welcome Reception is an informal and highly interactive environment that gives OOPSLA attendees the opportunity to engage with one another in discussions about relevant, ongoing work and critical issues in key areas. The session also gives conference attendees the chance to learn about work in areas with which they want to become familiar and about preliminary research results.
A special session, immediately following the OOPSLA 2003 Welcome Reception, targeted at first-time OOPSLA attendees, to help you maximize your OOPSLA experience. One thing that makes OOPSLA special is that everyone who participates can learn as long as everyone operates that way— OOPSLA is not a one-way (you listen, they speak) street. If you have never been to an OOPSLA before, this is a unique opportunity to meet other first-time OOPSLA participants early in the conference and begin what will become an outstanding way for you to stay on top of the trends in OO technology.