TechnologiesSunday, 26 OctoberMonday, 27 OctoberTuesday, 28 October
Wednesday, 29 OctoberThursday, 30 October
Today, domain-specific visual languages provide a viable solution to raise the level of abstraction beyond coding. Industrial experience has shown productivity improvements of 5-10 times. We believe that it is time to start talking about Domain-Specific Modeling as the new paradigm for developing applications and product families for a given domain/platform. In domain-specific modeling the models are constructed using concepts that represent things in the application domain, not concepts of a given programming language. The modeling language follows the domain abstractions and semantics, allowing developers to perceive themselves as working directly with domain concepts. Together with generators and components DSM can automate a large portion of software production. Workshop topics: Industry/academic experience reports
http://www.cis.uab.edu/info/OOPSLA-DSM03/
In software development projects it is necessary to find a common understanding of the architectural concept model. Concepts might be, for example, Business Objects, Services, or Forms. They provide the common "language" of the architects. To implement an adequate system architecture it is crucial for any software developer to share this "language." Usually a class structure alone cannot provide enough strength of expression to represent a concept model, since concepts might include several classes and even other software artifacts. We are looking for a structure above the class level, which comprises and communicates the additional semantics of the concept model. We will discuss ontologies to describe this structure. Ideally, the concepts themselves, their relations, hierarchies, and extension points, i.e. the ontology, should be detectable on source code level. We will examine modularization concepts and component models for implementation. Papers can range from academic research to practical experiences. Keywords: Ontology, Modularization, Architecture http://swt-www.informatik.uni-hamburg.de/conferences/workshop-oopsla2003.html
Concurrent programming has mostly been the domain of systems programmers rather than application developers, but Java's support for concurrency has enticed many to try their hand at building concurrent applications. Concurrent programming poses many traps for the unwary, however. This tutorial demonstrates various design patterns and techniques for constructing concurrent applications in Java and for managing that concurrency. On the language side, we examine Java's mechanisms to support concurrent programming. On the design side, we explore object structures and design rules that can successfully resolve the competing forces (safety, liveness, efficiency, coordination, reusability) present in concurrent software design problems. Attendee backgroundThis tutorial targets anyone involved, or planning to get involved, in the development of concurrent object-oriented applications. Prerequisites: Attendees should be familiar with basic OO concepts and must have a working knowledge of the Java programming language. FormatLecture PresentersDavid Holmes is Director and Chief Scientist of DLTeCH Pty Ltd, located in Brisbane, Australia. His work with Java technology has focused on concurrency and synchronization support in the language and virtual machine and he is currently working on a real-time Java virtual machine. David is a member of the expert group for JSR-166 "Concurrency Utilities" being developed under the Java Community Process. He has presented tutorials on concurrent Java programming and design at numerous international object-oriented programming conferences. Along with Ken Arnold and James Gosling, he is a co-author of the book "The Java Programming Language - Third Edition". David completed his Ph.D. at Macquarie University, Sydney, in 1999, in the area of synchronization within object-oriented systems. Doug Lea is a professor of Computer Science at the State University of New York at Oswego. He is author of the Java Series book "Concurrent Programming in Java: Design Principles and Patterns," co-author of the book "Object-Oriented System Development," and the author of several widely used software packages, as well as articles and reports on object-oriented software development. He is on the expert groups of numerous Java Specification Requests including JSR-166 "Concurrency Utilities" and JSR-133 "Java Memory Model".
AspectJ is a seamless, aspect-oriented extension to Java. It can be used to cleanly modularize the crosscutting structure of concerns such as exception handling, multi-object protocols, synchronization, performance optimizations, and resource sharing. When implemented in a non-aspect-oriented fashion, the code for these concerns typically becomes spread out across the program. AspectJ controls such code-tangling and makes the underlying concerns more apparent, making programs easier to develop and maintain. This tutorial will introduce Aspect-oriented programming and show how to use AspectJ to implement crosscutting concerns in a concise, modular way. We will also demonstrate and use AspectJ's integration with IDEs such as JBuilder, NetBeans, Emacs, and Eclipse, in addition to the core AspectJ tools. AspectJ is freely available at http://eclipse.org/aspectj. Attendee backgroundPrerequisites: Attendees should have experience doing object-oriented design and implementation, and should be able to read and write Java code. No prior experience with aspect-oriented programming or AspectJ is required. FormatLecture and demonstration PresentersErik Hilsdale is a researcher at the Palo Alto Research Center. As a member of the AspectJ team, he concentrated on language design, pedagogy and compiler implementation. He has written several conference and workshop publications in programming languages. He is an experienced and energetic instructor in programming languages and has much background in AspectJ. Jim Hugunin is a researcher at the Palo Alto Research Center. He built the first Java-based AspectJ compiler and led the subsequent implementation work up to a 1.1 release of the compiler and core tools. He also played a major role in the design of the AspectJ language. Prior to joining the AspectJ team he designed and implemented JPython/Jython, a widely used implementation of the Python language for the Java platform.
This tutorial illustrates the application of design patterns by example. We present in detail a real-world system and describe how it is designed with patterns, with a focus on distribution and concurrency, flexibility, and components. In particular, we will re-play the process of the system's construction step by step, discuss the design problems that occur, present one or more patterns that can help to address these problems, discuss which of the alternative patterns we selected and why, and show how we actually applied the selected patterns. This sequence illustrates how the design of the system slowly evolves towards the final architecture. We will also see that using patterns in practice is influenced by many factors: concrete constraints and requirements set by the application under development, limited or overstated understanding of particular patterns, varying developer skills, and also personal preferences. A major lesson that we can learn from this discussion is that there exists no "right pattern" for addressing a particular design problem, but rather, different patterns apply in different situations. A reflection on the case study leads us to general guidelines and golden rules for applying patterns in practise, and we discuss how these guidelines and rules aid in building high-quality software with predictable properties. The tutorial concludes with a summary of our experiences from several projects in which we applied patterns: what worked, what could be improved, and what we learned. Attendee backgroundPrerequisites: Attendees are expected to have sound knowledge of object technology, and basic knowledge of both UML notation and the pattern concept. FormatInteractive lecture PresenterFrank 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".
Semaphores and mutexes, latches and gates, pools and executors - these are all tools for managing threads within our applications. Each one has its own properties and purpose, and when used correctly, each can greatly simplify concurrent program design. The Java programming language has turned a generation of applications programmers into concurrent programmers through its direct support for multithreading. However, the Java concurrency primitives are just that: primitive. You can build many concurrency utilities from them, but doing so requires great care, as concurrent programming poses many traps for the unwary. Designing concurrent programs that can successfully resolve the competing forces of safety, liveness, efficiency, coordination, and reusability, is a task that can be greatly aided through the use of a good set of tools - a good concurrency utility library. This tutorial presents the components of a proposed concurrency utility library for the Java platform and being developed under JSR-166. We will look at the purpose and properties of each tool and how it fits into the concurrent design puzzle. We will also look at proposed extensions to the Java concurrency primitives. Attendee backgroundThis tutorial targets anyone involved, or planning to get involved, in the development of concurrent object-oriented applications in Java. Prerequisites: Attendees must be familiar with basic OO concepts and have a working knowledge of the Java programming language. Familiarity with Java's threading and synchronization mechanisms is desirable, but not essential. FormatLecture PresentersDoug Lea is a professor of Computer Science at the State University of New York at Oswego. He is author of the Java Series book "Concurrent Programming in Java: Design Principles and Patterns," co-author of the book "Object-Oriented System Development," and the author of several widely used software packages, as well as articles and reports on object-oriented software development. He is on the expert groups of numerous Java Specification Requests including JSR-166 "Concurrency Utilities" and JSR-133 "Java Memory Model". David Holmes is Director and Chief Scientist of DLTeCH Pty Ltd, located in Brisbane, Australia. His work with Java technology has focused on concurrency and synchronization support in the language and virtual machine and he is currently working on a real-time Java virtual machine. David is a member of the expert group for JSR-166 "Concurrency Utilities" being developed under the Java Community Process. He has presented tutorials on concurrent Java programming and design at numerous international object-oriented programming conferences. Along with Ken Arnold and James Gosling, he is a co-author of the book "The Java Programming Language - Third Edition". David completed his Ph.D. at Macquarie University, Sydney, in 1999, in the area of synchronization within object-oriented systems.
This tutorial will provide involved hands-on programming exercises that both use some of AspectJ's advanced features, and feature AspectJ used in advanced contexts. We will show how AspectJ can be used to solve problems in instrumentation (including logging), testing, quality management, and feature management. In addition, advanced parts of the AspectJ design and implementation will be introduced, along with discussions of possible future features. Exercises will use the core AspectJ tools and IDEs. AspectJ is freely available at http://eclipse.org/aspectj. Attendee backgroundPrerequisites: Knowledge of Java and some familiarity and experience with AspectJ, equivalent to the material covered in tutorial 4. FormatLecture and hands-on exercises PresentersErik Hilsdale is a researcher at the Palo Alto Research Center. As a member of the AspectJ team, he concentrated on language design, pedagogy and compiler implementation. He has written several conference and workshop publications in programming languages. He is an experienced and energetic instructor in programming languages and has a long history with AspectJ. Jim Hugunin is a researcher at the Palo Alto Research Center. He built the first Java-based AspectJ compiler and led the subsequent implementation work up to a 1.1 release of the compiler and core tools. He also played a major role in the design of the AspectJ language. Prior to joining the AspectJ team, he designed and implemented JPython/Jython, a widely used implementation of the Python language for the Java platform.
This intense and unique tutorial provides an introduction and step-by-step walkthrough of the state of the art of Web services (WS) and Service-oriented Architectures (SOA). The tutorial presents overviews of key web services standards (including WS-I, WSIF, WSIL, SOAP, WSDL, UDDI) considerations for their use, and some tools and technologies (including Apache Axis and related projects) that can be employed to implement them. Next, it presents an architectural blueprint for web services architecture that can server as a basis for most projects. With these standards, considerations, tools and blueprint in hand, we present a set of concrete process steps that lead to the realization of an SOA. The tutorial will then present a set of patterns for the design and implementation of web services based architectures including Business Service, Service Gateway, SOAP Document, and SOAP Method. We also discuss methods for assessment that can be used as checklists by architects who wish to evaluate web services architectures. Finally, to tie these togather, we will present two case studies, from the financial services and retail purchasing domains. Attendee backgroundPrerequisites: Basic knowledge of object-oriented development, and some knowledge of software architecture, design and implementation, are required. FormatLecture and hands-on exercises PresentersAli Arsanjani has over 19 years of industrial experience. He is a Senior Consulting I/T Architect for IBM's National E-business Application Development Center of Competency, where he leads the Component-based Development and Integration Competency area. He has been architecting n-tier e-business systems based on object, component, and service-oriented technologies for IBM's larger clients. His areas of experience and research include component-based development, service-oriented architectures, business rules modeling and implementation, creation and evolution of reusable assets, extending methods for CBD, building business frameworks and components and incorporating patterns and pattern languages to build resilient and stable software architectures. He has been actively speaking and publishing in these areas for a variety of industrial and academic audiences. Bruce Anderson is a Senior Consultant in IBM's Component Technology Services. He specialises in working with customer organisations to create powerful component- and object-based solutions, and in helping individuals to develop their knowledge and understanding. Typically, Mr. Anderson leads planning and definition work, and mentoring programme leaders, project managers or architects into their roles.
A number of Component-Based Architectures (CBAs) have been developed to facilitate the interoperability of software components that are written in different programming languages. The most widely known and used of these is OMG's Common Object Request Broker Architecture (CORBA) and Microsoft's Component Object Model (COM) and Distributed COM (DCOM). Although not specifically designed to provide language interoperability, many Java-based technologies, such as Enterprise Java Beans (EJB), also adhere to the principles of a CBA. The Common Language Infrastructure (CLI) is the latest CBA to be developed, and it builds on many of the lessons learned from previous architectures. In this tutorial, we will look at the major components of the CLI. The CLI is an ECMA standard on which Microsoft has built three implementations: the .NET Framework, the Compact Framework and the Shard Source CLI. The CLI is also the specification on which non-Microsoft implementations, such as Ximian's Mono, are based. Attendee backgroundPrerequisites: Attendees should have experience programming in an object-oriented programming language. Knowledge of a distributed/component architecture, such as CORBA or COM, is helpful. No familiarity with the CLI is required. FormatLecture PresenterDr. Damien Watkins is the founder and Managing Director of the software company "Project 42" and a Research Associate with the Distributed Systems and Technologies Centre. Prior to commencing Project 42, Damien lectured at the School of Computer Science and Software Engineering at Monash University. Damien is the primary author of "Programming in the .NET Environment" (Addison-Wesley 2003) and several papers on COM/DCOM, CORBA and the .NET Framework. Damien has presented tutorials on software architectures at OOPSLA 2002, SIGCSE 2002, TOOLS Pacific/Europe and the Microsoft Research Faculty Summit 2001/2002.
Eclipse is an increasingly popular Java-based open-source tooling platform. The platform provides support for Java program development, such as editing, compiling and debugging, and it is readily extensible through its plug-in mechanism. We have been involved in the development of a set of plug-ins that support the building and launching of embedded applications (with support for various platforms, such as J2ME/MIDP, PocketPC and PalmOS). We will show how applications can be developed, compiled, analyzed and compressed to fit on really small devices. We will demonstrate how to debug applications running in either an emulator or on a real device. We will also discuss how these Eclipse plug-ins were developed, what trade-offs we encountered, and what lessons we learned, and we will offer suggestions that will benefit (future) Eclipse plug-in writers. The tutorial will also include a demonstration of writing an actual plug-in for Eclipse. This technical tutorial will include lots of actual code and reports on practical experience. We will provide background information on developing Java applications for resource-constrained environments, such as PalmOS, and explain what Java standardization processes are under way in this area. Attendee backgroundPrerequisites: Attendees must have basic experience with Java and any interactive development environment. FormatLecture and demonstrations PresentersChris 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.
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:
http://www.voelter.de/conferences/oopsla03.html
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. http://www.softmetaware.com/oopsla2003/mda-workshop.html
The goal of this workshop is to foster precise, explicit, and elegant OO specifications of business and system semantics, independently of any (possible) realization. Substantial progress has been made in these areas, both in academia and in industry. However, in too many cases only lip service to semantic issues has been provided, and as a result the systems we build or buy are all too often excessively complex or (this is not an exclusive or) are not what they are supposed to be. Doing better than that requires both a clear understanding of the problem semantics within the context of their business and technological environments, and an abstract, precise and explicit specification of that semantics. The specific theme this year is on striving for simplicity. In order to simplify IT systems, we need to use abstraction — in C.A.R.Hoare's words, "only abstraction enables a manager or a chief programmer to exert real technical control". The same considerations apply to understanding, modeling and making (strategic, tactical and operational) decisions about businesses. http://www.ccs.neu.edu/home/kenb/oopsla2003
Pervasive Computing has become a reality and is further emerging. And even though Pervasive Computing is still in its infancy, no one can deny its potential to change how we live and do business. Pervasive Computing is pointing toward a future in which the networking web will be extended to an ever larger number of players, to smaller machines, houses, appliances, etc., which are increasingly becoming more intelligent. Applications and architectures are becoming multi modal and aware of their context. This web will allow machines to interact with other machines and humans. The sheer number of players interacting with each other and their penetration in our daily lives, such as household appliances, is going to make the impact even more formidable. In some respects, pervasive solutions contain many elements from standard e-Business systems and are implemented with the same or similar technology. However, the combination of the pervasiveness of computing functionality and internet access, together with possibilities such as the remote monitoring of events and pushing information to users and machines, or the creation of location-aware services, is a new paradigm. Clearly, the well-known Web 'Request/Response' model, as implemented through WAP or i-mode is not enough. Disconnected Work, Intelligent Notification, Ad Hoc Networks, and Data Replication are just a few samples usage patterns where Pervasive Computing goes beyond 'internet for small screens'. We believe Object Technology is playing a major part in shaping up this new computing paradigm. In some ways, objects can be regarded as becoming highly dynamic and more pervasive, 'living' on even the smallest device. The computing model is becoming even more distributed, possibly using Web Services as the prime means for cooperation. workshop will bring together practitioners who have been actively involved in the development of Pervasive Computing solutions, researchers who have been working in this area, and people who have been involved in the definition of standards. The goal is to identify recurring architecture themes and patterns typically used to build such systems, or raise issues and gaps for implementation that need to be resolved. The workshop is a sequel to similar sessions from the previous years at OOPSLA. It will start off with a short presentation of accepted papers and will then be highly interactive, aiming for tangible outcomes, such as sketches of reference architectures or patterns identified in this field. http://jeckstein.com/oopsla/pervasive-computing/
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. http://www.topquadrant.com/workshops/oopsla2003.htm
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/
This tutorial presents the issues facing modern high-performance garbage collectors and examines the approaches taken by state-of-the-art garbage collectors. Participants will gain a deeper insight into the operation of modern, high-performance garbage collectors. The tutorial will enable participants to evaluate the benefits and costs of such garbage collection algorithms, to understand the implications for their code and to make informed choices between collectors. Attendee backgroundPrerequisites: Participants must be experienced programmers familiar with basic garbage collection technology. Basic knowledge of OO implementation is useful but not essential. FormatLecture, animations, and demonstrations PresentersRichard 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. Attendee backgroundPrerequisites: Sound knowledge of the pattern concept and the GoF patterns are required. FormatInteractive lecture PresentersFrank 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.
Good performance, reliability, and maintainability are designed into software. The tutorial presents a guided tour through existing, industry-tested patterns that aid in the design of high performance, real-time, distributed and embedded systems, using a telecommunications system to structure the tour. The tour highlights various collections of patterns, as well as their sources -- books, conference notes and websites. Our objective is to make participants aware of these valuable resources that can greatly simplify their design work. By reusing a proven solution to frequently occurring problems, their efforts can be focused on the truly new portions of their design. Attendee backgroundPrerequisites: 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. FormatLecture PresenterRobert 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.
It's no longer enough to be able to develop fantastic applications; now they have to be able to coordinate with each other as well. Whether your sales application must interface with your inventory application, your procurement application must integrate with an auction site, or your PDAs PIM must synchronize with the corporate calendar server, just about any application can be made better by integrating it with other applications. Customers expect an integrated, single-application experience, regardless of how internal functionality may be split across applications, so applications must be integrated. This tutorial will teach you how to use messaging to integrate applications effectively by presenting a set of patterns--best practices that have been proven over time in a variety of integration projects. These patterns will teach you how to use message-based communication successfully. This tutorial is based on technology-agnostic patterns and applies to a variety of messaging technologies, ranging from the Java Message Service (JMS) API in J2EE, and the System.Messaging namespace in Microsoft .NET, to enterprise application integration (EAI) and middleware products from vendors such as IBM, TIBCO, WebMethods, SeeBeyond, Vitria and others. Attendee backgroundThis 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. FormatLecture PresentersBobby 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."
This tutorial presents an introduction to the interlocking business, organizational and technical issues that influence large-scale software reuse and asset-based software engineering. Asset reuse is one of the most significant enablers for productivity improvements; it appears simple at first glance, yet is difficult to execute. Most organizations do not know how to effectively structure a reuse program to match their business and software goals. We describe three primary flavors of reuse: Facilitated, Managed and Designed. An organization selects and practices one or more of these flavors of reuse by varying the amount of proactive management of assets and process; proactive design and architecture of assets to enhance reuse, and amount of top-down, pre-work, versus bottom up incremental reengineering. Particularly important is how it encourages or enforces use of these assets, how it invests in the people, process and technology to support the reuse program, and how it structures and manages the organization to provide, support and utilize the assets. Topics covered include: Business and economic issues; reuse experience; flavors of reuse; architecture, components, frameworks and product lines; reuse process and design methods, domain engineering; reuse governance and organization; and technology and tools such as templates, aspects, generators and repositories. Attendee backgroundPrerequisites: 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. FormatLecture and interactive discussion PresenterMartin 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.
This tutorial teaches participants how to apply AspectJ to enterprise application development using J2EE. It demonstrates some of the more advanced capabilities of AspectJ and how they can be used to address concerns such as security, caching, logging with Jakarta Commons, testing with JUnit, and more. The tutorial is based on a J2EE setting working with servlets, JSPs, EJBs and Web Services. It also compares AspectJ to AspectWerkz and JBoss AOP. Attendee backgroundPrerequisites: Attendees should have experience doing object-oriented design and implementation for IT applications. Attendees should have already experimented with AspectJ. FormatLectures and hands-on exercises PresentersRon Bodkin is the founder of New Aspects of Security, which extends AspectJ to provide security and privacy management for enterprise applications, and provides consulting on AOP and architecture. Previously, Ron worked for Xerox PARC, where he led the first AspectJ training and implementation projects for customers. Prior to that, Ron was a founder and the CTO of C-bridge, a consultancy that built and customized enterprise applications using Java, XML, and other Internet technologies. Adrian Colyer is an IBM UK Technical Staff Member with over 10 years of experience in developing enterprise middleware. He leads the open source AspectJ Development Tools for Eclipse project, and is also a committer on the core AspectJ compiler project.
Program generation has been used for a long time to facilitate the development of enterprise and embedded systems. More recently, its potential for improving object-oriented software development in general has been realized through the use of program generation techniques such as generative programming, product line engineering, and model-driven architectures (MDA). This tutorial introduces the most important kinds of code generation, such as model transformations, source code generation, source code transformation, byte code rewriting and reflection. We will introduce different code generation technologies, such as template-based generators, frame technology, aspect weaving and AST-based approaches; illustrate when to use them; discuss benefits and drawbacks of each approach; and look at representative tools that support each kind of program generation. Some of these tools will also be demonstrated. Attendee backgroundPrerequisites: Attendees should be experienced OO developers or architects and must understand an OO programming language, such as Java, C++ or C#. Familiarity with UML is also required. Previous experience with code generation is not necessary. FormatLecture and live demonstrations PresenterMarkus works as an independent consultant in software technology and engineering. He focuses on the architecture of large, distributed systems. Markus is the author of several magazine articles and patterns, a regular speaker at conferences, and co-author of Wiley's "Server Component Patterns." Over the last couple of years, Markus has architected and implemented several large enterprise systems in banking, diagnostics and automotive, on various scales. He has used code generation in the context of enterprise and embedded systems. Markus can be reached at voelter@acm.org or via http://www.voelter.de.
Creating enterprise-scale information systems poses many challenges, as such systems require integrating multiple (legacy) applications in such a way as to streamline and automate internal business processes and provide web-enabled business functions. The underlying architectures for such systems are embodied in a range of diverse products known as Enterprise Application Integration (EAI) technologies. This tutorial introduces EAI. It highlights some of the major issues in EAI technology selection, application design, and deployment. It introduces service-oriented architectures as a means of EAI, and presents some common architecture patterns for accomplishing EAI using J2EE and .NET. J2EE components covered will include the Java Messaging Service, Java Connector Architecture and supporting application server technology. In .NET, BizTalk, Web Services and various XML technologies will be described and illustrated. We will conclude with a detailed comparison of the strengths and weaknesses of J2EE and .NET technologies for EAI. Attendee backgroundPrerequisites: A solid understanding of object-oriented programming languages, such as Java, C++, or C#. Familiarity with the key features of distributed component technologies and enterprise platforms (e.g., J2EE, .NET) is useful but not required. FormatLecture and demonstrations PresentersIan Gorton is chief architect in information sciences and engineering at the US Department of Energy's Pacific Northwest National Laboratory. His research interests include software architectures, particularly large-scale, high-performance information systems that use commercial off-the-shelf (COTS) middleware technologies. Dr. Gorton received a PhD in Computer Science from Sheffield Hallam University. Anna Liu is an enterprise architect with Microsoft Australia. Her research interests include software architectures, patterns and best practices, and COTS software-evaluation and acquisition methods. Dr. Liu holds a BEng (with honors) and a PhD in computer engineering from the University of New South Wales, Australia.
Many organizations are adding mobile and wireless capabilities to their IT infrastructure. This tutorial explores technologies, designs and issues associated with the development of mobile and wireless software applications. In this tutorial, we explore how to leverage and reuse existing object-oriented system code for mobile and wireless applications. We also identify the pros/cons and development issues associated with various software application solutions, including Java, .NET, Wireless Application Protocol (WAP), and Brew. We examine the device market and its impact on software development. Finally, we discuss what makes for good and bad mobile/wireless software. Not unlike enterprise software, mobile/wireless software solutions must be appropriately designed. Some of the design and architecture issues are shared with those of bigger object-oriented applications. Other issues, especially around user interface and database synchronization, require special consideration. This tutorial exposes the mobile/wireless software architecture and design issues and potential solutions. Attendee backgroundThis tutorial is targeted to those individuals exploring mobile/wireless software application development. Prerequisites: Participants should have some familiarity with the basic concepts of software development and object-oriented programming. FormatLecture, examples, and demonstrations PresenterJames White is Wireless Practice Manager and Senior Consultant for Fourth Generation, Inc. based in St. Paul, MN. He is the co-author of "Java 2 Micro Edition" from Manning Publications and has written several articles on mobile/wireless computing, Java and object-oriented topics. Jim also finds time to speak frequently at industry conferences and spoke about J2ME at last year's JavaOne conference.
XML has grown out of the world of document management to become a broadly applicable technology that has impact on storage, messaging, and programming languages. This tutorial will look at the current landscape of XML technologies that are used to transmit, traverse, and transform XML-based information, with an emphasis on how these technologies impact current programming environments. Topics to be discussed include:
Attendee backgroundAttendees should have a basic familiarity with two or more type systems used in modern programming environments. FormatLecture PresenterDon Box is an architect on the XML Messaging team at Microsoft, where he works on defining and implementing the web service protocol stack. Don co-created the Simple Object Access Protocol (SOAP) and has helped develop SOAP-based technologies such as WS-Policy, WS-Reliable Messaging and WS-Addressing. Don has written several books on component technologies for Addison Wesley, beginning with "Essential COM," and most recently, "Essential .NET."
J2EE serves as a reference architecture for enterprise applications. It has gained widespread use over the past few years. For each part of a multi-tier enterprise application, J2EE provides both an implementation technology and a blueprint of how it should be used. Unfortunately, it is not always easy determine which J2EE technology to use in a given context, or how to use it. This tutorial explores different architectural alternatives available to developers when working with J2EE and describes when it is and is not appropriate to use each one. These guidelines are taken from experiences using J2EE for real-world, mission-critical applications. Attendee backgroundPrerequisites: Attendees should have some experience with using J2EE and possess a basic understanding of what the different constituents of J2EE are used for. FormatLecture and discussion PresentersMarkus Völter works as a freelance consultant for software technology and engineering. He focuses on the architecture of large, distributed systems. Markus is the author of several magazine articles and patterns, a regular Speaker at Conferences and co-author of Wiley's "Server Component Patterns - Component Infrastructures illustrated with EJB." Over the last couple of years, Markus has architected, coached and implemented on several J2EE systems in various domains (banking, diagnostics, automotive) and on various scales (ranging from 10 developers and 400 concurrent users up to 120 developers and 50,000 users). Dr. Arne Koschel works world-wide as Technical Product Manager and Product Specialist for IONA's Orbix Application Server Platform (ASP). Previously, he worked as independent Senior Object Technology Consultant and Enterprise Software-Architect with assignments throughout Europe and the United States. One of his major involvements (system architecture) for an Online Brokerage Application was selected as the major JavaOne 2001 J2EE customer success story. He is a regular speaker at conferences world-wide and author of many publications. He also cooperates with Universities, where he teaches courses in the areas of middleware and active databases.
Today, application development remains a laborious process, with relatively little reuse or automation. Application programmers must manually map their high-level analysis models to target platform architectures, such as J2EE and .NET, and eventually, to code. Rather than focusing on the problem domain, they have to deal with the complex details of the target platforms. The analysis and design models - being just additional documentation artifacts - are often not properly maintained in the face of approaching deadlines. This makes the applications hard to evolve later. Retargeting an application to a new platform is almost as difficult as writing it from scratch. Model-Driven Architecture (MDA) is a framework for model-based development being standardized by the Object Management Group (OMG) that addresses these problems. In MDA, models are the primary source of an application. All other artifacts, such as code, tests, and documentation, are (mostly) automatically derived from models. In this tutorial, we will take a critical look at the promises made by MDA and clearly distinguish what is possible today from the visions of tomorrow. After explaining basic MDA concepts, such as metamodeling and model transformations, we'll discuss tool requirements and review some existing MDA tools. We'll round up the tutorial with a demonstration of generating a complete J2EE and .NET application from the same high-level UML model. Attendee backgroundPrerequisites: Attendees should have basic knowledge of UML. FormatLectures and demonstrations PresentersDr. Krzysztof Czarnecki is an Assistant Professor at the University of Waterloo, Canada. Before coming to Waterloo, he spent 8 years at DaimlerChrysler Research working on the practical applications of generative programming (GP). He is co-author of the book "Generative Programming" (Addison-Wesley, 2000), which is regarded as seminal work of the area and is used as a graduate text at universities around the world. He is General Chair of the 2003 International Conference on Generative Programming and Component Engineering (GPCE). His current research focuses on realizing the synergies between GP and model-driven architectures. Petter Graff is Vice President of InferData Corporation. He has developed object-oriented systems for more than 20 years. At InferData, his focus is in object-oriented component development, software architectures and advanced implementation techniques for enterprise applications. He created one of the first model transformation tools (MCC) and is currently responsible for the development of InferData's next generation agent-based model transformation tool. Petter is also coauthoring an upcoming book on Model Driven Development (estimated to be published fall 2003). |