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 tutorial has 2 major parts: Part 1 discusses in detail all object-oriented concepts. The focus will be on a precise, non-confusing definition of the core concepts and terminology. Part 1 uses Java as its sample language to illustrate the material. Part 2 then compares major object-oriented programming languages: C++, Smalltalk, Java, 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 will be used to illustrate the solution in each language. Presentation Format: Presentation. Attendee Background: Attendees are 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. Attendees should have a fundamental background in computer science and/or computer programming. Raimund K. Ege is an Associate Professor of Computer Science at Florida International University, Miami. He is author of Programming in an Object-Oriented Environment (Academic Press, 1992) and Object-Oriented Programming with C++ (Academic Press, 1994). 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 several successful tutorials at major conferences. The tutorials were consistently rated highest and won praise from organizers and attendees.

Using only traditional techniques, the implementation of concerns like exception handling, multi-object protocols, execution tracing, and security policies tends to be spread out in the code. The lack of modularity for these concerns makes them difficult to develop and maintain. This tutorial will show how to use aspect-oriented programming to implement concerns like these in a concise modular way. We will discuss the effect aspects have on code modularity and on software design. The tutorial will work with AspectJ, a freely available aspect-oriented extension to the Java programming language. Participants will learn how to use aspect-oriented programming to solve real problems. After this tutorial, they will be able to apply aspects to their own object-oriented systems. Presentation Format: This tutorial will be 80% lecture and 20% design and coding exercises in groups. Attendee Background: Attendees should have object-oriented programming experience, and should be able to read Java syntax. Cristina Videira Lopes is a research scientist at the Xerox Palo Alto Research Center. Her research interests are in software engineering and programming languages. As a founding member of the AspectJ project, she is deeply involved in the design of the language and in the practical applications of AspectJ. She has been a co-organizer of several AOP-related workshops. For the last several years, she has been teaching novel programming techniques both for industry and academic audiences. She holds a Ph.D. in Computer Science and a BS and MS in Computer Engineering. Gregor Kiczales is a professor at the University of British Columbia, and a principal scientist at the Xerox Palo Alto Research Center. His research is centered around techniques that enable programs to as closely as possible look like the design they implement. He is the leader of the AspectJ project. He is a co-author of the book "The Art of the Metaobject Protocol." He has given invited talks at conferences such as OOPSLA, ECOOP, and ICSE.

This tutorial is for researchers and developers who want to use Java reliably, securely, and safely. This tutorial covers Java 2TM security, focusing on ClassLoaders, Class File Verifiers, SecurityManagers, and cryptography. Concepts such as ProtectionDomains, Policy, and privileged code will be explained in detail. The tutorial will also cover Java bytecode reverse engineering. Examples and scenarios will provide concrete examples of the technologies involved. This tutorial is based on Mr. Pistoia's latest book, "Java 2 Network Security," published by Prentice Hall PTR. Presentation Format: Presentation based, with code samples. Attendee Background: Attendees should be familiar with Java and object-oriented programming. Marco Pistoia is an Advisory Software Engineer, working at the IBM T. J. Watson Research Center in the Network Interactivity department. He has written nine books and taught classes world-wide on Java, WebSphere and e-business security. Marco's latest book, "Java 2 Network Security," is published by Prentice Hall PTR (ISBN 0-13-015592-6). Marco's interests are in mobile code security, security of collaborative systems, and object-oriented technology.

Explore the role and common challenges of software architecture found in modern object-oriented, distributed, and multi-tier systems. We look at the recent startling discoveries made by members of the patterns community investigating a variety of large real-life proprietary software systems and discuss the path of the new professional discipline: the software architect. An attendee will be able to address a number of critical design issues not commonly explored via UML or other popular modeling approaches that are nevertheless critical to the success of modern day, object-oriented, distributed, n-tiered systems. These issues include: system availability, security, scalability, survivability, long-lived flexibility, large scale granularity, data quality and maintenance, system metrics and reports, packaging and delivery mechanisms, as well as other key design decisions. Presentation Format: The teaching style is case-base driven, and hands-on in nature, with lecture intermixed to extend a participatory learning experience. As a result the attendee is assumed to have experience building at least one real-life software system of substantial size. Attendee Background: Minimum 3 years professional programming experience. Norm Kerth is a consultant working with mastering object-oriented technologies, including specification and design activities, quality assurance, continuous process improvement, project management and building effective teams. Prior to starting his company, Elite Systems, he was a professor at the University of Portland. He has a decade of engineering experience with Tektronix and is a master teacher, with over 25 years of experience in front of students and computer professionals. Gerard Meszaros is a consultant working with clients making the transition to object and component-based technology. A key component of these transitions is establishing software architecture as a cornerstone of the methodology. Prior to becoming a consultant, he was a software architect and project manager overseeing the development of software for switching telephone calls, a field where high availability and capacity requirements force close attention to software architecture. Jim Doble has worked in a variety of software development, management, and architecture roles within the telecommunications industry for 18 years. Jim started his career with Nortel, working primarily on central office switching system software, spent two years with Allen Telecom developing cellular infrastructure products, and is currently employed as chief software architect for Motorolaís Personal Communications Sector, where he is responsible for developing architectures for future generations of cellular phones. In addition to architecture, Jimís technical interests include patterns, prototyping, and tools development.

This tutorial will demonstrate how to create the software architecture of an application or a system using a pattern language. An introductory, background presentation will argue that architectural knowledge is "configurational knowledge" which is expressed through high-level structure but is not reducible to it. Software Architecture impacts on organizational structure and the creative process as well as on the technical system itself. Pattern languages can capture and express architectural knowledge, and therefore guide design in all these aspects. A subset of patterns from the ADAPTOR pattern language (authored by Alan O'Callaghan), together with some of Kevlin Henneyís distributed patterns, will be presented. In the hands-on part of the tutorial, using supplied materials (reference cards, etc.) the attendees will be split up in groups and will be asked to utilize the patterns supplied to develop an outline solution to a case study. Cross-group as well as intra-group collaboration will be required for a successful outcome. Entitled WindowShopper, the specification will be a subset of a real, current development for the retail supply industry that has utilized the ADAPTOR patterns in its development. In a summary section, attendees will get the chance to critically review what they have experienced. Presentation Format: The format is a combination of lecture presentation (punctuated by short supportive exercises) to introduce the pattern language (2 hours) and a group-based exercise to develop an architecture based on a case study (4 hours). Attendee Background: Developers of all kinds (i.e., architects, designers, analysts, programmers, etc.) with experience with object technology are welcome, but those charged with maintaining the conceptual integrity of large, legacy, or distributed systems will benefit most. Alan O'Callaghan is a senior researcher at De Montfort University's Software Technology Research Laboratory. Alan has been at DMU since 1989, having previously worked for companies such as the London Transport Executive, BOC Ltd., and Kodak UK. His research focus is on software architecture, reuse, software patterns, and the migration of legacy systems. He is also a sought after consultant to industry and has been involved in major projects in the telecommunications, defence, retail, and embedded command and control system industries. He has edited two books on applied OT and is currently writing two more. He writes a regular column in Application Development Advisor (formerly Object Expert) on legacy system migration. Alan is the author of the ADAPTOR pattern language. Alan is a member of the BCS Object Oriented Programming and Systems specialist group national committee, the IEEE, and the ACM Computer Society. He also is a member of both the Institute of Analysts and Programmers, and World Wide Institute of Software Architects Kevlin Henney is an independent trainer and consultant focusing on C++, Java, OO, design, patterns, and software architecture. He has written and delivered numerous courses on C++, Java, OOD, patterns, distributed objects, and component architectures. He was with QA Training, the leading UK IT training company, for four years. Prior to that he worked as a software engineer for a number of companies. He has been working with OO since 1990, and is known in the UK for his articles and presentations on patterns, design, C++, and Java. He is a member of the BSI (British Standards Institute) C++ standards panel. He is a columnist for C++ Report and Java Report and has written many articles for a variety of other magazines and journals. He is much in demand as a conference speaker and has presented tutorials and workshops at many conferences.

All projects begin with an exploration into requirements, building products that drive the entire software development process. At this point in the development lifecycle, a lack of quality can significantly impact a project’s future. Problems encountered in the development lifecycle can often be traced back to an improper or incomplete understanding of the problem to be solved. A solid process for software requirements analysis can significantly improve your project’s chances of success. Whether you plan to write a detailed requirements document according to IEEE specifications, or you plan to capture requirements in a spreadsheet, a strong UML model that demonstrates your understanding of your customer’s requirements should be your first step. This tutorial outlines a process for building UML models that capture an understanding of what your team must accomplish, maximizing the effectiveness of your requirements-gathering process. In sum, this tutorial will demonstrate how to build a UML model that substitutes for a detailed requirements document or serves as the foundation upon which to build a detailed requirements document. Presentation Format: 90 minute presentation followed by 5 exercise segments where the attendees work in small teams following the process as outlined. Attendee Background: Software professionals looking for ways to effectively capture an understanding of their customers’ requirements. Mr. Tim Szymanski is an expert in object-oriented technology. As a known speaker and publisher in the field, Mr. Szymanski brings a fresh and down-to-earth approach to implementing OO technology. Mr. Szymanski currently supports technical sales and OO consulting with Advanced Software Technologies, a leader in UML modeling technology and OO training. Mr. Szymanski began his career with 8 years as an officer in the United States Air Force, involved in a variety of sophisticated military and communications technologies. Mr. Szymanski’s work experience also includes: Reltec Corporation and Gateway Computers where his area of focus involved process improvement, implementation of UML technology, and commercial application development. Mr. Szymanski graduated from the United States Air Force Academy in 1990 with a Bachelor of Science degree in Electrical Engineering. In 1994 he received a Master of Science degree in Computer Science from California State University Sacramento. He may be contacted at: tszymanski@advancedsw.com.

This tutorial shows how use cases can be written, cross-connected, and managed. There will be no presentation slides in this tutorial. We shall discuss, write, examine, and consider the results, using continuous group exercises and discussions. This format will allow us to develop some facility with the underlying concepts, and work at different levels of precision, prior to writing use cases at different levels. Expect to encounter differences in writing styles and to discover that use cases are trickier to write than they seem. Learn the degrees of variation that still permit use cases to be effective. Topics will include: usage narratives, system scope, actors, goal levels, the new stakeholders and interests model underlying use cases, scenarios, failure detection and handling, connecting use cases, and of course, dealing with UML. The objective is to give attendees the theory and practice needed to write use cases effectively. At least 2/3 of the course time is spent writing and discussing. Presentation Format: Lecture, writing exercises, group discussion. Attendee Background: Anyone who is faced with gathering behavioral requirements for a software system, or for business process modeling. Typically from an IT department, but possibly from the human factors group, marketing department, or a user community. Alistair Cockburn, founder of Humans and Technology, was special advisor to the Central Bank of Norway and designed the OO methodology for the IBM Consulting Group in the mid-1990s. His “Surviving OO Projects” was published in 1998. He is an expert on use cases, object-oriented design, project management, and software methodologies. He has been the technical design coach and process consultant on projects ranging in size from 3 to 90 people. Materials that support Alistair’s workshops and tutorials can be found at http://members.aol.com/acockburn.

Industry studies show that the most productive software developers are 20 to 200 times more effective than their least productive counterparts. No other engineering discipline shows this divergence in practitioner competency level. This tutorial will present some of the techniques that allow developers to be incredibly effective, often doing in one day what others take weeks to accomplish. The participants will apply these techniques “hands-on” to the analysis, design, and implementation of a substantial real-world application. They will learn strategies to avoid time-wasting activities and will see how to build in extensibility from the ground-up, addressing future requirements that may not have been anticipated. Participants also will learn how to solve problems by finding and applying pattern languages during analysis, design, and programming. By the end of the tutorial, participants will not only learn about, but also help to build an application, taking it from concept to a functional prototype in only a day. Presentation Format: Lecture, discussion, and hands-on workshop. Attendee Background: This tutorial will assume and build on the participant having a good familiarity with Object Modeling, UML notation, the general concepts of Patterns and Pattern Languages, and at least one year experience programming in an object-oriented language. Michael Anton is Director of Software Development at Financial Technology Solutions Inc., a firm specializing is software development for the financial industry. He was a Senior Management Consultant for the last two years at an investment management firm in New York City, where he was also Manager of Fixed Income Systems for four years. Mr. Anton holds a Master of Science in Engineering (Computer & Information Science) from the University of Pennsylvania and a Bachelor of Arts in Economics and Chemistry from Williams College in Massachusetts. He has over twenty years experience designing, building, and managing software projects. Mr. Anton has been involved in Object-Oriented Development for twelve years and has contributed to many dozens of projects in portfolio management and trading, molecular modeling, directional drilling, traffic control, office automation, Microwave CAD and interactive voice response. Soo Lee is a Senior Software Engineer with over ten years experience in Object-Oriented Software Development.

One of the major challenges faced by enterprise Java developers is overcoming the mismatch between objects and relational databases. Storing objects in Java is more than simple JDBC calls; a solid design incorporates a persistence layer that separates the details of the database from the business logic. The persistence layer should address mapping and run-time issues such as: caching, object identity, inheritance, legacy database integration, querying, stored procedure use, objects stored in multiple tables, and transaction management. Additional challenges arise as more projects use three-tier architectures and application servers. The Enterprise JavaBean specification has also added integration requirements as developers build EJB compliant server components. Participants in this tutorial will learn about the issues involved with storing Java objects and Enterprise JavaBeans in relational databases. The design considerations in building and using a persistence layer will be discussed. Presentation Format: The presentation format will be slides with interactive discussion Attendee Background: Participants should have a basic knowledge of Java, object modeling and relational databases. A high level knowledge of Enterprise JavaBeans would also be of use for the sections focused on EJBs. Dennis Leung is the Director of Product Management at The Object People. He manages the TOPLink family of object-relational mapping tools. He has consulted with Fortune 500 companies world-wide on object-relational issues. Dennis has spoken at several conferences including: Smalltalk Solutions, Java Developers Conference, OOP Munich, OOPSLA, Sun Java Developer Days, and Java Expo Europe.

eXtreme Programming (XP) is a lightweight software development methodology that emphasizes ongoing user involvement, automated testing, and pay-as-you-go design. This tutorial introduces XP practices through hands-on exercises: Planning Game: User Stories, On-Site Customer Programming Game: Test-First Programming, Unit Testing, Pair Programming Refactoring Game: Code Smells, Once-and-Only-Once, Refactoring The exercises are paper-based and use a robot programming language. Student Volunteers help play the part of the customer and the unit testing framework. As a participant, you will help create a live simulation of several key practices of eXtreme Programming. Presentation Format: About 2/3 audience exercises, 1/3 slides and discussion. Attendee Background: Some familiarity with object-oriented concepts is helpful; no prior experience with XP is needed. Steve Metsker has been learning and writing about computer science since Jimmy Connors was the extreme in tennis and Jaws was the extreme in fish. In his writing, Steve has pursued topics that empower programmers, with articles on interpreters, OO weights and measures, and object relationship modeling. In his work, Steve has come to believe in involving users early, hooking requirements to testing, automating testing, and refactoring code. eXtreme Programming consolidates these practices and more into a lightweight methodology that works. In his current job, Steve actively injects XP practices into real world application development. William Wake has been programming almost as long. He is interested in XP, patterns, human-computer interaction, and information retrieval. He is author (with Stephen Drye) of “Java Foundation Classes: Swing Reference,” as well as several articles on other topics.

Combining object-oriented technology with the World Wide Web can be a complex affair for any project manager. The visibility and distributed nature of the Web may force you to deal with a host of issues that you are not likely to experience when managing traditional client/server projects. You will face an incredible tension between scalability, stability, and time to market from various project stakeholders. We will try to pass on techniques from our own bag of tricks to navigate this minefield. This session will draw from our own experience in managing successful Enterprise Java projects rather than standard project management theory. Tutorial participants will (1) learn to build realistic project plans and work breakdown structures, (2) understand how to evaluate and select your proposed tools and technologies, (3) explore hiring and training issues, and (4) learn to avoid some of the most common pitfalls on object-oriented Web projects. Presentation Format: This tutorial will be 70% presentation based. The remaining 30% will be a deep and free form discussion between the presenter and the audience Attendee Background: Project managers and developers interested in building an object-oriented Web application the right way. Skyler Thomas is a Senior Consultant with IBM WebSphere Services. He has been an active leader in Object Technology for over ten years. He is a recognized expert in project management for n-tier systems. He is also one of the gurus in the emerging field of personalization. He has consulted internationally with many companies in the Banking, Insurance, and E-Commerce industries. He has spoken at conferences like OOPSLA 99, JavaOne 99, and WebSphere 2000, and has published several OO-related articles.

This tutorial’s purpose is to demystify metaclasses and demonstrate a theory of how they can be used to increase productivity and reusability in object-oriented programming. The tutorial starts from first principles to construct an object model that is class-based (every object has a class) with first-class classes (every class is an object). After the object model is established, we introduce a metaobject protocol for manipulating the model. The metaobject protocol supports a new dimension for inheritance: inheritance of metaclass constraints. Based on this, we describe facilities required for composable metaclasses, that is, how a metaclass imparts to its instances the composite properties of its ancestor metaclasses. We conclude by demonstrating a number of useful metaclasses that do compose with each other. The attendee will attain an understanding of why metaclasses are a natural extension of object-oriented programming, how an object model with metaclasses can be easily programmed, how to construct a metaobject protocol, how metaclasses are composed, and what are some useful composable metaclasses. Presentation Format: Presentation. Attendee Background: The tutorial is intended for programmers who have a good understanding of object-oriented programming. Although the tutorial defines “class,” “method,” “inheritance,” etc., the tutorial is definitely an advanced course and one has to know the basics. 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. He started working in the area of object-oriented programming in 1984, when he worked at ITT Programming Technology Center. Forman received his Ph.D. in Computer Science from the University of Maryland, where he studied under Harlan Mills. Forman’s specialties are object-oriented 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.”

Typical OO development techniques assume systems with relatively large memories. Developers working with tight memory requirements need the flexibility and encapsulation that OO can provide, but cannot afford to produce large systems. This tutorial will describe how you can use OO techniques in a memory-constrained environment. Using design patterns and practical examples, this tutorial will teach the most important techniques that successful OO designers use for small memory software. This tutorial introduces participants to the techniques required to develop OO systems in limited-memory environments. After attending this tutorial, participants will be able to: understand the forces involved in designing small systems; design memory-efficient object structures and appreciate when they are appropriate; trade-off memory consumption and system responsiveness; and gracefully handle memory exhaustion by offering by limited service. Presentation Format: This tutorial balances direct presentations (for overviews and to present each pattern) and case studies (to reflect on patterns and see how they can be applied). Attendee Background: This tutorial targets anyone planning, or involved in, development of OO applications in limited memory. This tutorial is most useful to developers with a year’s experience using an OO language and technical team leaders. Experience of memory-limited systems is helpful but not essential. Dr. James Noble has recently returned home to lecture at the Victoria University of Wellington, New Zealand. While in Sydney, he established the Sydney Patterns Group, the first patterns group in the Southern Hemisphere, and he has extensive experience lecturing, teaching, and mentoring with software design, user interface design, and design patterns. Charles Weir has more than fifteen years’ experience with software development and OO techniques. Charles was technical lead for two major EPOC ‘smart mobile phone’ projects, and software architect for the Psion Series 5 Web Browser. Charles has taught many courses on OO design and implementation, and has led many active-learning sessions at the UK Object Technology series of conferences and elsewhere. James and Charles are collaborating on a book, “Small Memory Software,” describing patterns for memory-constrained systems, to be published by Addison-Wesley in 2000.

Today’s software architects have to choose between three different database techniques: object databases, relational databases, and object-relational databases. All of these have different advantages and liabilities. Most vendor statements are not fully dependable because they overemphasize the advantages of their product without mapping them to real-world requirements. A database paradigm that does not fit the project’s requirements may result in several severe problems including unsolvable performance problems and even project crashes. This tutorial teaches architects to choose between the various techniques and to find the solution that best fits their project. It discusses the techniques from an unbiased perspective. Consequently it discusses basic paradigms rather than actual products. After the tutorial, attendees should: know what the basic database paradigms are understand the differences between them understand the forces that drive a selection know how each database paradigm affects these forces know how to set up an evaluation of a database paradigm. Presentation Format: The tutorial will be a lecture with group exercises on specific case studies. Attendee Background: This tutorial is aimed at experienced designers of data-intensive applications. They should have basic knowledge of one relational or object database and should feel comfortable with object-oriented design. Jens Coldewey is an independent consultant from Munich, Germany, specialized in deploying object-oriented techniques in large organizations. He has published several articles, papers, and patterns on both object-oriented and relational databases. Wolfgang Keller is a manager of reusable software components for Generali insurance group in Vienna, Austria. His responsibilities include the technical base for Generali’s Phoenix line of insurance applications, product architecture and project coordination for Generali’s distributed development across parts of Europe.

The widgets in the Java AWT and JFC collections supply the fundamental components that are required for the construction of standard user interfaces. However, many situations require more specialized components to be developed. This tutorial will expose the processes involved in first developing a specialized component and then upgrading it to become JavaBean compliant. This will be done within the context of designing for usability and reusability from the outset. After the tutorial, attendees will be able to: distinguish internal from external event handling illustrate internal event handling within the context of a specialized component demonstrate designing for usability by means of STDs describe a minimum set of methods that should be considered when developing specialized components consider the stated requirements of a JavaBean illustrate the stepwise refinement of a specialized component into a JavaBean and demonstrate it within a bean tool Presentation Format: Presentation and demonstration. Attendee Background: An advanced tutorial intended for attendees who are already familiar with the use of the AWT or JFC widget set and who wish to learn how to develop specialized components for particular requirements within the context of the JavaBean specification. Fintan Culwin is a Reader in Software Engineering Education at South Bank University: London specializing in Software Engineering and HCI, particularly in the integration of usability considerations in the earliest stages of production processes. He has published five books, including two on Java, and is currently completing a sixth on the JFC. He has published extensively on Internet issues and has presented sessions on the Web and Java at a series of international conferences including: SIGCSE ‘97, 98, & 99, BCS HCI ‘96, ‘97, & ‘98, ITiCSE ‘98, CHI ‘99, and OOPSLA ‘98 & ‘99.

This tutorial covers OMG’s Object Management Architecture including CORBA, the CORBAservices and CORBAfacilities, and the Domain CORBAfacilities. Starting with a brief look at requirements and needs in distributed Internet and enterprise computing and how UML, the MOF, and XMI support the rest of the OMG specifications, the tutorial moves on to cover OMG Interface Definition Language and mappings to various programming languages, the structure and function of the Object Request Broker, network interoperability and the standard protocols GIOP and IIOP, integration with Java and COM/DCOM, and the Portable Object Adapter (POA) and how it supports a scalable server-side infrastructure. After taking this tutorial, attendees will be able to judge if a project is suitable for CORBA, and move on to the next step in their own CORBA education, whether through books or formal training course. The tutorial also provides enough background to enable attendees to understand the companion OOPSLA tutorial “What’s New in CORBA 3?” Presentation Format: Presentation. Attendee Background: The tutorial assumes that attendees will be new to CORBA, but familiarity with OO concepts or an OO language will be helpful. Dr. Jon Siegel, OMG’s Director of Technology Transfer, heads OMG’s technology transfer program with the goal of teaching the technical aspects and benefits of the Object Management Architecture, including CORBA, the CORBAservices, the Domain specifications in vertical markets ranging from healthcare, life sciences, and telecommunications to manufacturing and retail systems, and the modeling specifications UML, MOF, and XMI. In this capacity, he presents tutorials, seminars, and company briefings around the world, and writes magazine articles and books including the popular “CORBA 3 Fundamentals and Programming.” With OMG since 1993, Siegel previously chaired the Domain Technology Committee responsible for OMG specifications in the vertical domains.

E-Business is about business-driven technology-enabled change that is much deeper than just Web-enablement. The challenges of an e-business transformation include things as diverse as integration of business processes, front- and back-office applications, the customer, the products, the competition, and continued agility. The e-business cycle includes everything from business objectives and analysis, architecture and implementation, deployment and operations monitoring, and eventual return on investment. It forces you to question and re-think fundamentals taken for granted previously, such as outsourcing arbitrary portions of a business’ processes. And it demands careful attention to architectural infrastructure. In this tutorial we examine specific aspects of component-based development and modeling that directly support an e-business transformation, using the UML/Catalysis approach. Participants will become acquainted with a component-based modeling and development framework that addresses many of the issues encountered in an e-business project in a consistent and cohesive way. Presentation Format: Mostly interactive presentation, with some optional short exercises to emphasize key concepts. Attendee Background: Participants should be familiar with both e-business and UML modeling. Desmond D’Souza is president of Catalysis.org. Developer of the Catalysis method for the systematic development of business-driven component systems, and co-author of a book on this topic published by Addison Wesley, he was previously senior vice president of component-based development at Computer Associates and Platinum Technology, responsible for defining methods, tools, and architectures for effective component-based software engineering. Desmond has worked with object and component technology since 1985, and is a frequent invited speaker and consultant at companies internationally.

Concurrent programming has mostly been the domain of systems programmers rather than application developers, but Java’s support of concurrency has enticed many to try their hand at concurrent applications. However concurrent programming poses many traps for the unwary. This tutorial demonstrates various design patterns and techniques for constructing concurrent applications in Java and for managing that concurrency. On the language side we look at Java’s mechanisms to support concurrent programming. On the design side we look at object structures and design rules that can successfully resolve the competing forces (safety, liveness, efficiency, coordination, reusability) present in concurrent software design problems. Participants will acquire comprehensive knowledge of the concurrency support provided by the Java language and core classes, as well as insight into some threading issues within the Java libraries. They will be exposed to a range of design approaches to assist them in developing safe, concurrent applications in Java and other object-oriented languages. Presentation Format: This tutorial will be presentation based. Attendee Background: This tutorial targets anyone involved, or planning to get involved, in the development of concurrent object-oriented applications. It is assumed that the attendee is familiar with basic OO concepts and has a working knowledge of the Java programming language. David Holmes is a Senior Research Scientist at the Cooperative Research Centre for Enterprise Distributed Systems Technology (DSTC Pty, Ltd.), in Brisbane, Australia. He completed his Ph.D. in the area of synchronization within object-oriented systems and has been involved in concurrent programming for a number of years. He is a co-author of the third edition of the Java Series book “The Java Programming Language.” 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.

As the use of UML grows and UML is applied to more fields of software and systems engineering, the need for more precise specifications grows. This is crucial, for example, when generating code or test cases from specifications. In the component-based world we need to be able to specify the behavior of components in a very precise way. This enables us to know whether components are plug-compatible and can work together. For these purposes UML’s Object Constraint Language is becoming popular as a standardized and language independent specification mechanism. This tutorial shows the importance of constraints as an object-oriented specification technique and how they add value to the visual modeling techniques of UML. The OCL language itself and the connection with the visual UML diagrams are thoroughly explained. The final part of the tutorial will show how one can apply constraint modeling in UML to achieve the above-described goals. After this tutorial, the attendees will be able to understand the added value of constraints for their modeling and component based work. They will understand UML’s Object Constraint Language and know how it integrates with UML diagrams. Presentation Format: The tutorial is a mixture of presentation and small exercises. Attendee Background: The tutorial is targeted to people who have experience with analysis and design methods like UML. Jos Warmer has been active in the OT community since 1985. Currently he is working at Klasse Objecten as a senior consultant. He used to work within IBM’s European Object Technology Practice (OTP). Jos co-authored the UML 1.1 proposal for the OMG. He is still responsible for the UML Object Constraint Language with the OMG’s UML core team. He is the chief architect of OCL. Anneke Kleppe has over ten years of experience with object technology. Currently she is an independent consultant in the area of object technology within her own company called Klasse Objecten (in English that would translate to “Class Objects”). Her job is to coach and train companies working with object technology. Some of the companies she has worked for are PTT Telecom, NCR Nederland NV, IBM Education and Training, and the Dutch government. Anneke Kleppe and Jos Warmer are the authors of “The Object Constraint Language: Precise Modeling with UML,” part of the Addison Wesley’s OT series. They also authored two Dutch books: “Praktisch OMT” and “Praktisch UML” (translated: Practical UML), on OMT and UML. All books are published by Addison-Wesley.

Designing object-oriented software is hard, and designing reusable object-oriented software is even harder. Experience shows that many object-oriented systems exhibit recurring structures or “design patterns” of communicating and collaborating objects that promote extensibility, flexibility, and reusability. This course describes a set of fundamental design patterns and, through a design scenario, demonstrates how to build reusable object-oriented software with them. The course covers the roles design patterns play in the object-oriented development process: how they provide a common vocabulary, reduce system complexity, and how they act as reusable architectural elements that contribute to an overall system architecture. This course is designed for software developers, including architects and programmers. Participants will acquire experience using design patterns to solve real problems. This experience will enhance participants’ design abilities by teaching them how to apply design patterns to their own object-oriented systems. Presentation Format: Presentation Attendee Background: Attendees should understand basic object-oriented concepts, like polymorphism and type versus interface inheritance, and should have had some experience designing object-oriented systems. No prior knowledge of design patterns is required. Familiarity with Java is recommended. John Vlissides is a member of the research staff at the IBM T. J. Watson Research Center in Hawthorne, NY. He has practiced object-oriented technology for over a decade as a designer, implementer, researcher, lecturer, and consultant. John is author of “Pattern Hatching,” co-author of “Design Patterns” and “Object-Oriented Application Frameworks,” and co-editor of “Pattern Languages of Program Design 2.” He is also Consulting Editor of Addison-Wesley’s Software Patterns Series. John has published numerous technical papers and is a columnist for the C++ Report.

The increased complexity associated with large-scale software development requires an increase in the sophistication of the methodology utilized. The third generation method/process RUP is described in detail and then evaluated for its efficacy in industry. This leads to suggestions to extend and recast it to remove its identified deficiencies. The result is the Object-oriented Process, Environment and Notation, or OPEN, method/process, a public domain, third-generation approach, which is then outlined. The overall aims of the tutorial are to critically evaluate RUP and OPEN as the two most viable OO/CBD (Component-Based Development) processes available today. Presentation Format: Lecture. Attendee Background: Fully conversant with basic OO terminology and the need for a full lifecycle process. Experience with OO methodologies is advantageous. This tutorial is of particular interest to project managers, systems developers, analysts, and designers who require information on modern OOAD methodological/process thinking. Brian Henderson-Sellers is Director of the Centre for Object Technology Applications and Research (COTAR) and Professor of Information Systems at the University of Technology, Sydney (UTS). He is author of eight books on object technology and is well-known for his work in OO methodologies and metamodelling (MOSES, COMMA, and OPEN) and in OO metrics. He was recently voted number 3 in Who’s Who of Object Technology (“Handbook of Object Technology,” 1999, Appendix N).

Reflection is a programming technique for object-oriented architectures to provide better extensibility of a system (especially at run-time) and means for uniform generic behavior (such as persistency). While languages like Smalltalk and Java provide built-in mechanisms for reflection, C++ lacks such a provision. Though several well-known patterns exist for implementing reflection through a metaobject protocol in C++, they typically require the usage of this protocol for all access to the real (non-meta) classes, forcing an unnatural style of programming. This tutorial presents some lesser-known C++ constructs that can be used to provide metaclass facilities to existing normal C++ classes, enabling both normal direct access and reflective access to these classes. Participants will acquire a thorough understanding of the potentials of reflective programming techniques and some patterns to implement them effectively in C++. One major application of the presented techniques will be shown in the tutorial “XML Dynamically with C++.” Presentation Format: Presentation based. Attendee Background: Participants should have a good working knowledge of ISO C++. Advanced features of the language used in this tutorial will be explained. Detlef Vollmann has a background of 15 years in software engineering and more than 10 years with object technology. As an independent consultant he supports several Swiss companies with the design of object-oriented systems. Since 1991 he has authored and taught courses in C++, Object-Oriented Technologies, Software Architecture, and Distributed Computing for Swiss Digicomp AG.

This tutorial is for people who want to find out more about eXtreme Programming with an eye toward improving the software development process. Managing the incremental, iterative development processes required by modern software systems is not easy, so it is useful to see what lessons can be learned from the process that has taken incremental development to extremes. eXtreme Programming projects manage to be successful with a 3 week delivery cycle, incrementally gathering requirements and adding fully tested, useful system features every increment. This tutorial is intended to prepare the participant to become actively involved in experimenting with and tuning their current development process. Presentation Format: This tutorial will be an inquiry directed through the use of presentation material. For each of the lessons identified there will be group inquiry and discussion about the applicability of the lesson to other development processes. Attendee Background: The tutorial is targeted to those individuals interested in identifying individual and group software development practices that will allow them to improve their delivery capability. Pete McBreen is a course designer, teacher, and project lead in object technology. He is responsible for ensuring that project teams make effective use of object technology on projects including project startup, methodology and tool selection, mentoring, process improvement, system design, and quality assurance. With over 15 years of industry experience, he has been successfully using and teaching OO techniques since 1989.

The Catalysis method (www.catalysis.org) provides a simple and consistent use of UML to: (a) treat “objects” and “use cases” in a fractal manner, from business to code, (b) specify and design large-grain to small components using “types” and “collaborations,” (c) use a “plug-in” framework approach from requirements patterns, through architecture and design, to code, and (d) define component architectures based on an extensible “kit” of architectural modeling elements. This tutorial provides an overview of the key concepts and the development process. Participants will learn how to model components in an abstract yet precise way, how to relate component models to business requirements, and how to use modeling patterns as building blocks for everything from requirements through design. Presentation Format: Mostly presentation. Attendee Background: Attendees should be familiar with object modeling and programming, design patterns, and use cases. Those wanting to use patterns with UML, seeking a consistent component-based approach from requirements to code, and using languages like Java, will particularly benefit. Desmond D’Souza is president of Catalysis.org. Co-author and developer of the Catalysis method for the systematic development of business-driven component systems, and a book on this topic published by Addison Wesley, he was previously senior vice president of component-based development at Computer Associates and Platinum Technology, responsible for defining methods, tools, and architectures for effective component-based software engineering. Desmond has worked with object and component technology since 1985, and is a frequent invited speaker and consultant at companies internationally.

The last twenty years have seen a lot of work in modeling methods: techniques to help people understand how software works. In the last few years the Unified Modeling Language (UML) has become the standard notation for describing object-oriented designs. This tutorial gives you an outline of the UML and additional useful techniques. We’ll cover such techniques as Use Cases, Class Diagrams, and Interaction Diagrams, together with non-UML techniques like CRC Cards and Design by Contract. We’ll also see how these techniques fit into a simple incremental development process. This tutorial is a Grand Tour of the UML. There isn’t time in half a day to go into great detail on any of the techniques within it, but there is a chance to get a feel for what each technique looks like, when to use it, and where to find out more. You’ll also get tips on using them from someone with plenty of object-oriented scars. Presentation Format: Lecture. Attendee Background: Attendees should be familiar with basic OO concepts. Craig Larman is the author of “Applying UML and Patterns–An Introduction to Object-Oriented Analysis and Design,” the best-selling text on object-oriented analysis and design and the UML. He also co-authored the “Java 2 Performance and Idiom Guide” and writes the “Modeling and Java” column in Java Report. Craig is a popular conference speaker, and conference or advisory board member, at events such as OOPSLA, Software Development, and UML World. Craig serves as Director, Process and Methodology, at Valtech, an international consulting group with divisions in Europe and the USA. He has been using object technologies since 1984 when he started developing knowledge systems on LISP machines. For many years he has assisted others in developing object systems, adopting practical development processes, and in learning to apply object-oriented analysis and design, C++, Java, and Smalltalk. Craig holds a B.Sc. and M.Sc. in computer science, with research emphasis in artificial intelligence, object-oriented knowledge representation, and case-based reasoning.

Smart, well-designed, and correct C++ programs can sometimes be highly inefficient. In many cases it is possible to dramatically reduce these efficiency problems (without giving up the abstraction) using a variety of techniques and idioms. This tutorial presents a series of C++ programming idioms for writing efficient C++ programs. The tutorial looks at class and class hierarchical design, the efficient use of the STL containers and generic algorithms, and such issues as locality of declaration and the Proxy design pattern. Participants will gain an understanding of the underlying C++ object model and language idioms in support of that model. With this knowledge, the participants should find themselves programming more efficiently and with more confidence. Presentation Format: Presentation and demonstration. Attendee Background: The attendees should be familiar with the standard C++ programming language. Stanley Lippman is a member of technical staff at DreamWorks Feature Animation where he is currently technical lead for a real-time Pencil Test system with audio synchronization. Prior to this, Stan was a principal software engineer at Walt Disney Feature Animation, and a member of technical staff at Bell Laboratories where he was involved in the development of C++. He is the author of “C++ Primer” (co-authored with Josee Lajoie), “Inside the C++ Object Model,” and “Essential C++.”

Typical OO development techniques assume systems with relatively large memories. Developers working with tight memory requirements need the flexibility and encapsulation that OO can provide, but cannot afford to produce large systems. This tutorial will describe how you can use OO techniques in a memory-constrained environment. Using design patterns and practical examples, this tutorial will teach the most important techniques that successful OO designers use for small memory software. After attending this tutorial, participants will be able to: Prepare a memory budget Design a software architecture and component interfaces to minimize memory use Track memory consumption through the development process, and Tailor user interfaces for small software Presentation Format: This tutorial balances direct presentations (for overviews and to present each pattern) and case studies (to reflect on patterns and see how they can be applied). Attendee Background: This tutorial targets anyone planning, or involved in, development of OO applications in limited memory platforms. This tutorial is most useful to developers with a year’s experience using an OO language and technical team leaders. Experience of memory-limited systems is helpful but not essential. Dr. James Noble has recently returned home to lecture at the Victoria University of Wellington, New Zealand. While in Sydney, he established the Sydney Patterns Group, the first patterns group in the Southern Hemisphere, and he has extensive experience lecturing, teaching, and mentoring with software design, user interface design, and design patterns. Charles Weir has more than fifteen years’ experience with software development and OO techniques. Charles was technical lead for two major EPOC ‘smart mobile phone’ projects, and software architect for the Psion Series 5 Web Browser. Charles has taught many courses on OO design and implementation, and has led many active-learning sessions at the UK Object Technology series of conferences and elsewhere. James and Charles are collaborating on a book entitled “Small Memory Software” describing patterns for memory-constrained systems, to be published by Addison-Wesley in 2000.

How are object-oriented languages implemented? What features of object-oriented languages are expensive? What optimizations have been developed to make object-oriented languages more efficient? This tutorial addresses these questions. After identifying the main features of object-oriented languages that are challenging to implement efficiently, three classes of implementation techniques are presented. First, run-time system techniques such as virtual function dispatch tables (including complications due to multiple inheritance and virtual inheritance) and inline caches are described. Second, static intra- and inter-procedural analyses are discussed that seek to identify at compile-time the possible classes of message receivers, in order to reduce or eliminate the overhead of dynamic binding. Third, ways in which dynamic execution profiles can be exploited to complement static analysis techniques are described. To assess the relative importance of the techniques, empirical measurements of the effectiveness of many of these techniques, as implemented in the Vortex optimizing compiler, are presented for large benchmarks written in Java, C++, and Cecil. Attendees will become familiar with the issues and state-of-the-art techniques for implementing object-oriented languages efficiently. Presentation Format: This tutorial will be presentation based. Attendee Background: Attendees should be familiar with the features of object-oriented languages and also with traditional compiler techniques such as procedure inlining and data flow analysis. Craig Chambers has been researching object-oriented language design and implementation since 1987, with publications in OOPSLA, ECOOP, ISOTAS, PLDI, POPL, PEPM, and TOPLAS on the topic. For his Ph.D. thesis at Stanford, he developed the first efficient implementation of the Self language, using optimizing dynamic compilation. Chambers is currently an Associate Professor of Computer Science & Engineering at the University of Washington, where he designed the Cecil language, heads the Vortex whole-program optimizing compiler project, and co-leads the DyC staged dynamic compilation project.

The Java Foundation Classes supply a collection of user interface components. This tutorial attempts to introduce a representative selection of the most useful of them, showing how they can be combined to produce effective user interfaces. To accomplish this, it is necessary to start with a representation of the required behavior and derive the detailed design from it. The objectives of this tutorial are: To provide an introduction to the widgets supplied by the JFC To introduce usability heuristics and style guides that can be employed in the detailed design To show how State Transition Diagrams can describe the required behavior To introduce the Java event dispatch/ listener model To illustrate layout management policies To illustrate STD, Class, Instance, Interface Layout, and Object Interaction Diagram notations To illustrate the realization of three-layer designs in Java To introduce presentation resource management techniques Presentation Format: Presentation and demonstration. Attendee Background: An intermediate level tutorial for attendees who have an initial familiarity with OO concepts and wish to develop further understanding in the context of GUI construction. Most of the exposition is at the source code level. Fintan Culwin is a Reader in Software Engineering Education at South Bank University: London specializing in Software Engineering and HCI, particularly in the integration of usability considerations in the earliest stages of production processes. He has published five books, including two on Java, and is currently completing a sixth on the JFC. He has published extensively on Internet issues and has presented sessions on the Web and Java at a series of international conferences including: SIGCSE ‘97, 98, & 99, BCS HCI ‘96, ‘97, & ‘98, ITiCSE ‘98, CHI ‘99, and OOPSLA ‘98 & ‘99.

Recent additions to the set of OMG standards bring CORBA into the world of modern networking: the Internet and corporate intranets, with their requirements for high throughput and large numbers of objects storing correspondingly large amounts of data, as well as specialized environments such as real-time and embedded systems. Under the banner CORBA 3, these additions fall into three major categories: Java and Internet Integration, including a reverse mapping from an Java to OMG IDL, an IIOP Firewall specification, and a definition of URLs for CORBA objects on the Internet Quality of Service Control, including a complete set of asynchronous and messaging invocation modes, QoS management, and specifications for Real-Time, Embedded (minimal), and Fault-Tolerant CORBA The CORBA Component Model (CCM), which packages up the most successful server development patterns into a sophisticated development and run-time environment After taking this tutorial, attendees will be familiar with all of the different parts of the CORBA 3 specification. Presentation Format: Presentation Attendee Background: Attendees should be familiar with fundamental CORBA concepts. Attendance at the companion tutorial “Introduction to OMG’s CORBA and Object Management Architecture” is sufficient. Jon Siegel, Ph.D., OMG’s Director of Technology Transfer, heads OMG’s technology transfer program with the goal of teaching the technical aspects and benefits of the Object Management Architecture including CORBA, the CORBAservices, the Domain specifications in vertical markets ranging from healthcare, life sciences, and telecommunications to manufacturing and retail systems, and the modeling specifications UML, MOF, and XMI. In this capacity, he presents tutorials, seminars, and company briefings around the world, and writes magazine articles and books including the popular “CORBA 3 Fundamentals and Programming.” With OMG since 1993, Siegel previously chaired the Domain Technology Committee responsible for OMG specifications in the vertical domains.

As more and more business is done over the Web, the notion of accessing and using software over the Internet not only by humans using browsers but also by portals and other applications has become increasingly popular. Building systems of such remote applications – often referred to as e-services – has its special technological and methodological requirements. Participants will learn about: E-Services: What are e-services? How are they different from distributed objects in an Intranet? E-Speak: Get a basic understanding about the requirements and characteristics of e-services platforms, taking e-speak, an open source platform for deploying e-services (http://www.e-speak.net), as example. We will discuss issues like pay per use, service advertisement, service brokering, communication mediation, firewall piercing using WebAccess, and requesting e-services by exchanging XML documents. Architecting e-services systems: What are the processes and models for defining e-services and e-services contracts and determining the overall architecture of e-services systems? How do you document the architecture of e-services systems? What are the similarities and differences to architecture models and processes of traditional systems? Presentation Format: The style of the tutorial will be mainly presentation, with an example to work on during the second half of the tutorial about designing an e-services system. Attendee Background: This tutorial is aimed at software engineers, architects, project managers. Basic familiarity with C++ or Java and UML is preferable. Dorothea Beringer is a consultant in the architectural consultancy group in Hewlett Packard’s Product Generation Services where she provides support to architects in designing and recapturing the architecture of software and firmware products and product lines. She has a Ph.D. in software engineering, has been publishing and teaching in academia and industry, and has lately researched e-services at Stanford University. Derek Coleman leads the architecture practice in Hewlett-Packard’s Product Generation Consultancy. His current research interest is in all aspects of the development of software, firmware, and product architectures. Derek is also a Visiting Professor at Kings College, London. Until he rejoined Hewlett-Packard in 1998, Derek was Head of Department of Computer Science at King’s. Prior to this, Derek was a manager at HP Labs in Palo Alto and Bristol (England). At Bristol, Derek led the development of the original Fusion Method. Derek has presented tutorials at OOPSLA, ECOOP, Software Development, UML World, and many other conferences. He is also regularly involved in developing and presenting training courses and webcasts to HP audiences. Mike Ogush is a member of the architecture practice area in Hewlett-Packard’s Product Generation Consultancy. His research interest is applying the front-end of the software development process (requirements through design) to the development of product lines and solutions. Since 1991, Mike has developed materials for, and lead training courses on, Software Architecture, UML for Software development, the Fusion OO analysis & design process, as well as briefer presentations and webcasts on reuse, requirements, architecture, and design. Between 1978 and 1991, Mike developed applications directed at improving programmer, software engineer, and circuit board designer productivity.

Through targeted exercises, attendees are introduced to real-world issues and solutions of enterprise-level component-based development using EJB/J2EE. The context is development of data-centric, transactional, e-business, and distributed systems that must scale at development-time and at run-time. The solutions proposed by the presenter are justified through a brief formalization of the concepts, including a detailed analysis of the differences between distributed objects and well-designed enterprise components, various architectural styles (e.g., instance-based vs. type-based, state-based vs. stateless) and relative scalability, approaches to persistence required by large systems, and generally speaking the main architectural principles required for scalable distributed systems. The tutorial covers shortcomings of the J2EE specification, and situates EJB/J2EE in the larger context of serious component-based systems for the enterprise. Attendees will come away with a detailed understanding of the issues, principles, and approaches required to use J2EE/EJB for large-scale distributed system development Presentation Format: 40% interactive exercises, 30% discussing presenter’s solution, 30% concepts formalization. Attendee Background: Participants should have a general familiarity with distributed system development issues, and preferably with object-oriented analysis and design. Familiarity the J2EE/EJB specification is recommended. The intended audience is professionals charged with architecting, developing, or managing large-scale distributed systems with EJB/J2EE Peter Herzum, co-founder and Chief Technology Officer of Vayda & Herzum, is considered the guru of component-based development for the enterprise. Peter is the creator of the Business Component Approach, the first approach entirely based on components, and principal author of the groundbreaking book, “Business Component Factory: A Comprehensive Overview of Component-Based Development for the Enterprise,” which has been described by analysts as “the bible of e-business component development.” Peter has over 15 years experience in the industry, and he has led large-scale component-based product development and solution development since 1992. Peter also has extensive experience in consulting, mentoring, and training for large organizations. He is a frequent speaker at conferences across the world (including tutorials at OOPSLA‘99, OOP2000, ObjectWorld, Component Development, SIGS Java Development, XML ONE, and others), and an active member of the OMG. Peter holds a Dr. Eng. degree in Computer Science from the Politecnico di Milano.

Concurrent programming has mostly been the domain of systems programmers rather than application developers, but Java’s support of concurrency has enticed many to try their hand at concurrent applications. Effectively creating and managing concurrency within an application poses many design choices and trade-offs. This tutorial looks at more advanced issues in designing concurrent applications. It describes mechanisms for introducing concurrency into applications (threads, message-passing, asynchronous calls) and different models for application architectures, such as data-flow and event-driven designs. The tutorial also shows how concurrency controls can be abstracted into reusable support classes, and finally discusses how concurrent components and applications should be documented. Participants will learn how concurrent applications can be structured in different ways and how different mechanisms can be used to effect concurrent behavior. They will be exposed to a range of design patterns and techniques for introducing and managing concurrency within their applications and how to create reusable concurrency abstractions. Presentation Format: This tutorial will be presentation based. Attendee Background: This tutorial targets anyone involved, or planning to get involved, in the development of concurrent object-oriented applications. It is expected that the attendee is very familiar with OO concepts and the Java language, and has a good working knowledge of Java’s concurrency mechanisms. David Holmes is a Senior Research Scientist at the Cooperative Research Centre for Enterprise Distributed Systems Technology (DSTC Pty, Ltd.), in Brisbane, Australia. He completed his Ph.D. in the area of synchronization within object-oriented system and has been involved in concurrent programming for a number of years. He is a co-author of the third edition of the Java Series book “The Java Programming Language.” 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.