Sunday, 26 October
Monday, 27 October
Tuesday, 28 October
Wednesday, 29 October
Thursday, 30 October
Software product lines have emerged as a new and very important software development paradigm. A software product line is a set of software-intensive systems sharing a common, managed set of features, and that are developed in a disciplined fashion using a common set of core assets. Organizations developing their family of products as a software product line are experiencing order-of-magnitude improvements in cost, time to market, staff productivity, and quality of the deployed products. This tutorial covers the basic concepts of software product lines, the essential software engineering and management practices, and product line practice patterns that let an organization apply the practices in a way best suited to their individual needs. The concepts are illustrated with one or more detailed case studies of actual organizations' experiences with the software product line approach. The tutorial contents are based on the book "Software Product Lines: Practices and Patterns."
Prerequisites: Participants should have experience in designing and developing software-intensive systems and some familiarity with modern software engineering concepts and management practices.
Lecture (65%) with discussion (20%) and short exercises (15%)
Linda Northrop is currently director of the Product Line Systems Program at the Software Engineering Institute (SEI). She is co-author of the book, "Software Product Lines: Practices and Patterns." She received the 2001 Carnegie Science Center Award for Excellence in Information technology, was a keynote speaker at ICSE 2001 and AOSD 2002, OOPSLA Program Chair in 1999, OOPSLA Conference Chair in 2001, and the Conference Chair of the first and second international Software Product Line Conference (SPLC1 and SPLC2). She chaired the first Software Product Line Conference and is the current OOPSLA Steering Committee Chair.
Paul C. Clements is a Senior Member of the Technical Staff at Carnegie Mellon University's Software Engineering Institute. He is co-author of four books on architecture and product lines: "Software Product Lines: Practices and Patterns," "Software Architecture in Practice," "Evaluating Software Architectures: Methods and Case Studies," and "Documenting Software Architectures: Views and Beyond."
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.
Industry/academic experience reports
Product-line architectures promise better productivity and less maintenance costs for families of related software systems. A strong product-line architecture is one of the keys to a successful deployment of both product lines and any system destined to go through multiple releases. However, specifying high-quality product-line architectures is a surprisingly difficult task.
Commonality and variability analysis is a powerful domain analysis tool for the specification of product lines. It can help designers produce systems that are robust in the face of change, and that can be easily customized. Additionally, it feeds naturally into OO design. This combination provides a proactive, systematic approach to accomodating changes in software.
This tutorial introduces commonality and variability analysis in a real-world setting. Topics include: underlying principles, methodology, and synthesis with OO design. By the end of the tutorial, you will understand how to use commonality and variability analysis in your OO projects to specify a stable, yet flexible, software architecture.
This tutorial is aimed at architects and designers of systems that have many variations, such as product families and systems with multiple releases.
Prerequisites: Attendees should have solid background in OO principles, and some OO design experience. Experience in specification or analysis is helpful but not required.
Lecture with exercises
Neil Harrison is a researcher at Avaya Labs, where he consults with software projects in architecture, process, organizations, estimation, and product line engineering. He has been involved in software patterns since 1994. He has organized pattern conferences and has taught many courses on patterns. He is a member of the Hillside Group board of directors. He has published patterns and chapters in pattern books, and was lead editor of Pattern Languages of Program Design, Volume 4.
Frank Buschmann is senior principal engineer at Siemens Corporate Technology in Munich, Germany. His interests include Object Technology, Software Architecture, and Patterns. Frank has been involved in many software development projects. He is leading Siemens' software architecture research activities. Frank is co-author of "Pattern-Oriented Software Architecture -- A System of Patterns" and "Pattern-Oriented Software Architecture -- Patterns for Concurrent and Networked Objects".
The main goals of software reuse are to increase quality, reduce cost, and shorten development cycles. The interesting question in this context is: How to achieve reuse in constrained environments? In desktop and enterprise systems, object-orientation, components, frameworks, service-oriented architectures and, most recently, model-driven development are proposed as cornerstones for efficient reuse. In constrained environments (i.e. embedded and real time systems, PDAs, smart phones, settop boxes) reuse is not as simple, because most reuse techniques imply some kind of overhead: memory, performance, or determinism.
This workshop explores practical reuse techniques for constrained environments. Potential topics include, but are not limited to:
Model Driven Architecture (MDA) is an initiative by the OMG to leverage UML-based modeling techniques to insulate abstract software system specifications from implementation dependencies. The workshop focuses on generative techniques that can be used to realize MDA. We aim to bring together practitioners, researchers, academics, and students to discuss the state-of-the-art of generative techniques in the context of MDA. The OOPSLA'02 workshop on this topic was highly successful and led to the launch of the Generative Model Transformer (GMT) open source initiative.
Topics of interest include:
The goal is to share experience, consolidate successful techniques, and identify the most promising application areas and open issues for future work.
Large information systems need a domain model. Development teams know this, yet they often end up with little more than data schemas. This tutorial delves into how a team, developers and domain experts together, can engage in progressively deeper exploration of their problem domain while making that understanding tangible as a practical software design. This model is not just a diagram or an analysis artifact. It provides the very foundation of the design, the driving force of analysis, even the basis of the language spoken on the project.
The tutorial will focus on three topics:
The tutorial will include group reading and discussion of selected patterns from the book "Domain-Driven Design," Addison-Wesley 2003, and reenactments of domain modeling scenarios.
Prerequisites: Attendees must have a basic understanding of object-oriented modeling and the ability to read UML. Some involvement, past or present, in a complex software development project is helpful in seeing the applicability of the material, but is not essential. Familiarity with the practices of Agile Methods and/or Extreme Programming is helpful, but not essential.
Interactive reading/discussion session, and simulations of the activities and processes that go into making domain design decisions.
Eric Evans is a specialist in domain modeling and design in large business systems. Since the early 1990s, he has worked on many projects developing large business systems with objects and, since 1999, has been deeply involved in three projects committed to the Extreme Programming process (XP), and has trained teams in the Extreme Programming process. Out of this range of experiences have emerged the synthesis of principles and techniques shared in the book "Domain-Driven Design," Addison-Wesley 2003.
Ralph Johnson is a co-author of the now-legendary book, "Design Patterns" (Addison-Wesley, 1995). He is on the faculty of the Department of Computer Science at the University of Illinois. He is the leader of the UIUC patterns/Software Architecture Group and the coordinator of the senior projects program for the department. His professional interests cover nearly all things object-oriented, especially frameworks, patterns, business objects, Smalltalk, COM and refactoring.
This tutorial presents an introduction to the interlocking business, organizational and technical issues that influence large-scale software reuse and asset-based software engineering. Asset reuse is one of the most significant enablers for productivity improvements; it appears simple at first glance, yet is difficult to execute. Most organizations do not know how to effectively structure a reuse program to match their business and software goals. We describe three primary flavors of reuse: Facilitated, Managed and Designed. An organization selects and practices one or more of these flavors of reuse by varying the amount of proactive management of assets and process; proactive design and architecture of assets to enhance reuse, and amount of top-down, pre-work, versus bottom up incremental reengineering. Particularly important is how it encourages or enforces use of these assets, how it invests in the people, process and technology to support the reuse program, and how it structures and manages the organization to provide, support and utilize the assets. Topics covered include: Business and economic issues; reuse experience; flavors of reuse; architecture, components, frameworks and product lines; reuse process and design methods, domain engineering; reuse governance and organization; and technology and tools such as templates, aspects, generators and repositories.
Prerequisites: This tutorial is geared towards managers, architects and senior developers who have some software engineering, programming and modeling experience, and who are eager to establish or refine an asset reuse program.
Lecture and interactive discussion
Martin Griss is one of the world's leading authorities on software reuse. He spent nearly two decades as Principal Laboratory Scientist and Laboratory Director at Hewlett-Packard Laboratories. Known as HP's "Reuse Rabbi," he created and led a corporate-wide software reuse program. His research has covered software reuse processes and tools, software engineering tools and methods, and software agents. He is co-author of "Software Reuse: Architecture, Process and Organization for Business Success," and author of over 60 book chapters, papers, columns and reports. He is an Adjunct Professor of Computer Science at the University of California at Santa Cruz, a consultant, and member of Flashline's Software Development Productivity Council.
The Generic Modeling Environment (GME) is a metaprogrammable, domain specific, graphical editor supporting the design, analysis and synthesis of complex, software-intensive systems. It is closely related to metaCASE tools such as MetaEdit+ or Dome. Over a decade of research in model integrated computing has led to the development of GME. The toolset has been applied to modeling and synthesizing several real world applications for both government and industry organizations.
GME has an architecture based on MS COM technology and is implemented in C++. The Core component exposes the domain-specific language specification through a set of COM interfaces. It has another set of interfaces for model access. All the other components, (GUI, browser, OCL constraint manager, software generators, etc.) are built independently around the Core. Model persistence is supported via standard database technology and XML persistence. The technologies applied throughout GME (UML, OCL, COM, XML) make it easily applicable and extensible.
The demonstration will focus on using GME to develop an integrated simulation framework for embedded systems. The UML and OCL based metamodels specifying the domain-specific visual modeling language will be examined. We'll demonstrate how the domain-specific environment is automatically generated from these metamodels. We'll emphasize how the target visual language supports such OO concepts as type inheritance and multiple aspects. The automatic extension of the model access interface will be shown. This interface makes extensive use of OO techniques such as inheritance. We'll show an example application, including its complex models and the automatically synthesized simulation and C code.
Feature-Oriented Programming (FOP) is both a design methodology and supporting tools for program synthesis. The goal is to specify a target program in terms of the features that it offers, and to synthesize an efficient program that meets these specifications. FOP has been used successfully to develop product lines in widely varying real-world domains, including compilers for extensible Java dialects, fire support simulators for the U.S. Army, network protocols, and program verification tools.
AHEAD is a simple mathematical model of FOP that is based on step-wise refinement, a methodology for building programs by adding one feature at a time. The incremental units of implementation/design are refinements that encapsulate the implementation of an individual feature. AHEAD models of product lines treat base programs as constants and program refinements as functions (that add a specified feature to the input program). Application designs are thus equations--compositions of functions and constants--that are amenable to optimization and analysis.
This tutorial reviews basic results on FOP, including general models and tools for synthesizing a consistent set of code and non-code artifacts by composing refinements (cross-cuts), automatic algorithms for validating refinement compositions, synthesizing product-lines of product-families (e.g., tool suites), and automatic algorithms for optimizing application designs (equations).
Prerequisites: Participants should understand basic concepts of object orientation, but no other special background is necessary.
Don Batory holds the David Bruton Centennial Professorship at The University of Texas at Austin. He received a B.S. (1975) and M.Sc. (1977) degrees from Case Institute of Technology, and a Ph.D. (1980) from the University of Toronto. He was a faculty member at the University of Florida in 1981 before he joined the Department of Computer Sciences at the University of Texas in 1983.
He was an Associate Editor of IEEE Transactions on Software Engineering (1999-2002), Associate Editor of ACM Transactions on Database Systems (1986-1992), a member of the ACM Software Systems Award Committee (1989-1993; Committee Chairman in 1992), Program Co-Chair for the 2002 Generative Programming and Component Engineering Conference, the Program Chair for the 1995 International Conference on Software Reuse, and the 1999 Workshop on Software Reuse. He has given numerous lectures and tutorials on product-line architectures, generators, and reuse, and is an industry consultant on product lines.
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.
Prerequisites: Attendees should be experienced OO developers or architects and must understand an OO programming language, such as Java, C++ or C#. Familiarity with UML is also required. Previous experience with code generation is not necessary.
Lecture and live demonstrations
Markus works as an independent consultant in software technology and engineering. He focuses on the architecture of large, distributed systems. Markus is the author of several magazine articles and patterns, a regular speaker at conferences, and co-author of Wiley's "Server Component Patterns." Over the last couple of years, Markus has architected and implemented several large enterprise systems in banking, diagnostics and automotive, on various scales. He has used code generation in the context of enterprise and embedded systems. Markus can be reached at email@example.com or via http://www.voelter.de.
The Generative Model Transformer (GMT) project is an Open Source initiative to build a Model Driven Architecture™ tool that allows fully customisable Platform Independent Models, Platform Description Models, Mappings, and Refinement Transformations. The project should result in:
GMT resides as a technology project on Eclipse.org.
The demo intends to show the state of the tool at the time of OOPSLA.
The software is designed using UML modeling and implemented using generative techniques. It will be implemented mainly in Java. Links will be provided to other existing tools that can fill in some of the functionality required.
GMT will provide a related set of components that can be used by other MDA tool components, and will consist of four main components:
MetaEdit+ is an environment that allows building modeling tools and generators fitting to application domains, without having to write a single line of code. The capability to define modeling tools and generators is relevant as it provides the ability to raise the abstraction of design work from code to domain concepts, and a raise in abstraction leads to an imminent raise in productivity, as illustrated by the past years' experiences.
In domain-specific modeling and MetaEdit+, one expert defines a domain-specific language as a metamodel containing the domain concepts and rules, and specifies the mapping from that to code in a domain-specific code generator. For the method implementation, MetaEdit+ provides a metamodeling language and tool suite for defining the method concepts, their properties, associated rules, symbols, checking reports, and generators.
Once the expert defines a modeling method, or even a partial prototype, the rest of the team can start to use it in MetaEdit+ to make models with the modeling language and the required code is automatically generated from those models. Based on the metamodel, MetaEdit+ automatically provides CASE tool functionality: diagramming editors, browsers, generators, multi-user/project/platform support, etc. MetaEdit+ is implemented in Smalltalk.
The MetaEdit+ demo will focus on showing how the domain-specific languages and generators are made; complete with several examples of domain-specific methods and related code generators.
Keywords: metamodel; domain-specific modeling languages; code generators
In most business software systems the time dimension of business objects plays a significant role. Time is a crosscutting concern that is hard to separate from other business logic. We have developed a toolkit that allows existing business application systems to be extended with "time-conscious" behavior in a non-intrusive way by factoring out all aspects of time-related behavior into a framework and a set of classes that is distinct from the existing code base. The Time Conscious Objects™ (TCO) toolkit is currently implemented in Java™, but through the use of generation technology the toolkit can easily be made available in any language that supports polymorphism.
The TCO toolkit has been explicitly designed to allow non-intrusive and incremental integration into existing systems. Time-conscious objects can have a major impact on the quality and maintainability of applications by eliminating the complexity of dealing with the time dimension. This is the case for example in time-based billing systems, in the insurance industry, and in the modeling of "parts" in ERP and manufacturing systems.
The demonstration provides an overview of the architecture and the APIs that TCO uses to integrate with existing application system environments. Beyond that, the demonstration shows on the basis of one or more small example applications, how TCO can be used to raise the level of abstraction in platform independent models and in business application code.
TCO product development is work-in-progress and the demonstration is intended to be highly interactive, giving the audience opportunity to raise and discuss their specific time-dimension-related requirements.
Software for embedded systems faces some special constraints not found in other domains. One of these constraints is a hard limitation on available RAM/ROM, processing power, and other resources. To cope with these limitations without losing the reusability of the software components, product line technologies are a promising approach. However, adequate tools for variant management are still rare.
In the demonstration we will apply Pure::Consul, a tool which supports the description of problem and solution domains of product lines, software families, or other variable artifacts in a highly flexible manner, to a realistic application scenario: a weather station product line running on a small 8 bit microcontroller with only a few KBytes of memory.
Problem domain modeling with Pure::Consul is based on extended feature models. The tool allows for integration of many different variability realization techniques through its customizable transformation backend. Thus, it is able to incorporate frame processors, code generators, or arbitrary other tools.
The implementation of the presented product line is based on AspectC++, an aspect-oriented extension to C++. We will demonstrate that by applying aspect-oriented software development, the number of configuration points in the code can be reduced. Both tools together form an ideal tool chain for embedded software product line development as one reduces the configuration complexity on the source code level, while the other helps to manage the variability on the abstract feature level and provides a mapping of features to aspects, classes, or other modularization units.
Model Driven Architecture (MDA) is a technology that has been in the process of evolution for many years. Today, many vendors are now producing products that support MDA. We are hearing more and more success stories that indicate that this technology is the "real deal". But, with the failed promises of CASE in the late 1980's, many people still have questions about how much of an application can be generated from models and constraint languages. Is MDA really capable of generating enterprise applications? What are the technologies are available to implement MDA? Here is your opportunity to ask the experts the questions that are necessary to convince you of the validity of this new technology. Each of these panelists has been intricately involved in building the underlying foundations of Model Driven Architecture and its implementation.
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.
Prerequisites: Attendees should have basic knowledge of UML.
Lectures and demonstrations
Dr. Krzysztof Czarnecki is an Assistant Professor at the University of Waterloo, Canada. Before coming to Waterloo, he spent 8 years at DaimlerChrysler Research working on the practical applications of generative programming (GP). He is co-author of the book "Generative Programming" (Addison-Wesley, 2000), which is regarded as seminal work of the area and is used as a graduate text at universities around the world. He is General Chair of the 2003 International Conference on Generative Programming and Component Engineering (GPCE). His current research focuses on realizing the synergies between GP and model-driven architectures.
Petter Graff is Vice President of InferData Corporation. He has developed object-oriented systems for more than 20 years. At InferData, his focus is in object-oriented component development, software architectures and advanced implementation techniques for enterprise applications. He created one of the first model transformation tools (MCC) and is currently responsible for the development of InferData's next generation agent-based model transformation tool. Petter is also coauthoring an upcoming book on Model Driven Development (estimated to be published fall 2003).