Analysis, Design & Architecture

Sunday, 26 October

Monday, 27 October

Tuesday, 28 October

Wednesday, 29 October

Thursday, 30 October

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

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

Attendee background

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

Format

Lecture

Presenter

Kevlin Henney is an independent consultant and trainer. The focus of his work is in programming languages, object orientation, component-based development, UML, patterns, and software architecture. He is a regular columnist for C/C++ Users Journal (online), Application Development Advisor (UK), and JavaSpektrum (Germany), and previously wrote columns in Java Report and C++ Report. He is also a member of the advisory board for Hillside Europe, the program chair for EuroPLoP 2003, and a popular speaker at conferences in the US and Europe.

Today, domain-specific visual languages provide a viable solution to raise the level of abstraction beyond coding. Industrial experience has shown productivity improvements of 5-10 times. We believe that it is time to start talking about Domain-Specific Modeling as the new paradigm for developing applications and product families for a given domain/platform.

In domain-specific modeling the models are constructed using concepts that represent things in the application domain, not concepts of a given programming language. The modeling language follows the domain abstractions and semantics, allowing developers to perceive themselves as working directly with domain concepts. Together with generators and components DSM can automate a large portion of software production.

Workshop topics:

Industry/academic experience reports

• Approaches to identify constructs for DSMs
• Novel approaches for code generation from domain-specific models
• Issues of support/maintenance for systems built with DSMs
• Evolution of languages in accordance with domain
• Metamodeling frameworks and languages
• Tools for supporting DSMs

http://www.cis.uab.edu/info/OOPSLA-DSM03/

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

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

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

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

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

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

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

Attendee background

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

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

Format

Lecture with exercises

Presenters

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

Frank Buschmann is senior principal engineer at Siemens Corporate Technology in Munich, Germany. His interests include Object Technology, Software Architecture, and Patterns. Frank has been involved in many software development projects. He is leading Siemens' software architecture research activities. Frank is co-author of "Pattern-Oriented Software Architecture -- A System of Patterns" and "Pattern-Oriented Software Architecture -- Patterns for Concurrent and Networked Objects".

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

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

Attendee background

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

Format

Interactive lecture and programming demonstration

Presenters

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

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

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

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

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

This tutorial illustrates the application of design patterns by example. We present in detail a real-world system and describe how it is designed with patterns, with a focus on distribution and concurrency, flexibility, and components. In particular, we will re-play the process of the system's construction step by step, discuss the design problems that occur, present one or more patterns that can help to address these problems, discuss which of the alternative patterns we selected and why, and show how we actually applied the selected patterns. This sequence illustrates how the design of the system slowly evolves towards the final architecture. We will also see that using patterns in practice is influenced by many factors: concrete constraints and requirements set by the application under development, limited or overstated understanding of particular patterns, varying developer skills, and also personal preferences. A major lesson that we can learn from this discussion is that there exists no "right pattern" for addressing a particular design problem, but rather, different patterns apply in different situations.

A reflection on the case study leads us to general guidelines and golden rules for applying patterns in practise, and we discuss how these guidelines and rules aid in building high-quality software with predictable properties. The tutorial concludes with a summary of our experiences from several projects in which we applied patterns: what worked, what could be improved, and what we learned.

Attendee background

Prerequisites: Attendees are expected to have sound knowledge of object technology, and basic knowledge of both UML notation and the pattern concept.

Format

Interactive lecture

Presenter

Frank Buschmann is senior principal engineer at Siemens Corporate Technology in Munich, Germany. His interests include Object Technology, Frameworks and Patterns. Frank has been involved in many software development projects. He is leading Siemens' pattern research activities. Frank is co-author of "Pattern-Oriented Software Architecture -- A System of Patterns" and "Pattern-Oriented Software Architecture -- Patterns for Concurrent and Networked Objects".

This intense and unique tutorial provides an introduction and step-by-step walkthrough of the state of the art of Web services (WS) and Service-oriented Architectures (SOA).

The tutorial presents overviews of key web services standards (including WS-I, WSIF, WSIL, SOAP, WSDL, UDDI) considerations for their use, and some tools and technologies (including Apache Axis and related projects) that can be employed to implement them. Next, it presents an architectural blueprint for web services architecture that can server as a basis for most projects. With these standards, considerations, tools and blueprint in hand, we present a set of concrete process steps that lead to the realization of an SOA.

The tutorial will then present a set of patterns for the design and implementation of web services based architectures including Business Service, Service Gateway, SOAP Document, and SOAP Method. We also discuss methods for assessment that can be used as checklists by architects who wish to evaluate web services architectures.

Finally, to tie these togather, we will present two case studies, from the financial services and retail purchasing domains.

Attendee background

Prerequisites: Basic knowledge of object-oriented development, and some knowledge of software architecture, design and implementation, are required.

Format

Lecture and hands-on exercises

Presenters

Ali Arsanjani has over 19 years of industrial experience. He is a Senior Consulting I/T Architect for IBM's National E-business Application Development Center of Competency, where he leads the Component-based Development and Integration Competency area. He has been architecting n-tier e-business systems based on object, component, and service-oriented technologies for IBM's larger clients. His areas of experience and research include component-based development, service-oriented architectures, business rules modeling and implementation, creation and evolution of reusable assets, extending methods for CBD, building business frameworks and components and incorporating patterns and pattern languages to build resilient and stable software architectures. He has been actively speaking and publishing in these areas for a variety of industrial and academic audiences.

Bruce Anderson is a Senior Consultant in IBM's Component Technology Services. He specialises in working with customer organisations to create powerful component- and object-based solutions, and in helping individuals to develop their knowledge and understanding. Typically, Mr. Anderson leads planning and definition work, and mentoring programme leaders, project managers or architects into their roles.

This tutorial is a short, quick-paced introduction to object-oriented analysis and design, based on practical project experience. It will provide you with the knowledge and skills to:

• Create use case documents
• Understand object-oriented concepts, terminology and buzzwords
• Identify classes and create class diagrams
• Understand and use the Unified Modeling Language (UML), identify behaviors and create sequence diagrams, and recognize other UML diagrams
• Gain an understanding of what patterns are and review 5 of the "gang of four" design patterns

Attendee background

This tutorial is targeted to people who are new to objects and object-oriented concepts. It is intended for people who have had some exposure to objects but need more knowledge to be able to put all the pieces together.

Format

Lecture

Presenters

Jill Aden has worked for 18 years with EDS as a Systems Architect and has worked with objects since 1993. She is a member of the OTUG group at the University of St. Thomas in St. Paul, MN and served as the Communications Chair at OOPSLA 2002. Ms. Aden is in the process of writing an object-oriented analysis and design book for undergraduate students. At EDS, she mentors, consults, and teaches object-oriented concepts internally and externally to clients.

Joseph Brennan is a System Architect with EDS, where he has worked for 18 years. He is a member of the Twin Cities Java User Group and has been working with objects for 10 years. Mr. Brennan is in the process of writing an object-oriented analysis and design book for undergraduate students. At EDS, Joseph mentors, consults, and teaches object-oriented development and concepts within EDS and externally to clients. Joseph is a Sun Certified Java Instructor and Java Developer.

Developing concurrent and networked object-oriented applications is hard; developing high-quality reusable components for these types of applications is even harder. The principles, methods, and skills required to develop reusable software cannot be learned by generalities. This tutorial, therefore, illustrates by example how to significantly simplify and enhance the development of communication software that effectively utilizes concurrency and distribution via the use of:

• Object-oriented design techniques, such as patterns, layered modularity, and data/control abstraction
• Object-oriented language features, such as abstract classes, inheritance, dynamic binding, and parameterized types
• Middleware, such as object-oriented frameworks for host infrastructure middleware (e.g., ACE) and component middleware (like J2EE, the CORBA Component Model, and .NET)
• Advanced operating system mechanisms, such as event demultiplexing, multi-threading, multi-processing, and explicit dynamic linking

The tutorial examines patterns and framework solutions abstracted from production systems in domains including from telecommunications, avionics, online trading systems, medical systems, web servers, and real-time object request brokers to illustrate the key technical design and implementation issues. The material presented in this tutorial is based on the book "Pattern-Oriented Software Architecture: Patterns for Concurrent and Networked Objects," Wiley & Sons, 2000.

Attendee background

Prerequisites: Participants must be familiar with object-oriented development techniques (such as patterns, modularity, and information hiding), OO language features (such as classes, inheritance, dynamic binding, and parameterized types), systems programming concepts (such as process/thread management, synchronization, and IPC), and networking terminology (such as client/server architectures and TCP/IP).

Format

Lecture

Presenter

Dr. Douglas C. Schmidt is a Professor in the Electrical Engineering and Computer Science department at Vanderbilt University. His research focuses on patterns, optimization techniques, and empirical analyses of object-oriented frameworks that facilitate the development of distributed real-time and embedded (DRE) middleware. Dr. Schmidt has over fifteen years of experience developing DRE middleware as the chief architect and developer of ACE and TAO, which are widely used, open-source middleware containing a rich set of components that implement patterns for DRE systems. Dr. Schmidt has also served as a Deputy Director and a Program Manager at DARPA, where he led the national R&D effort on DRE middleware.

The main goals of software reuse are to increase quality, reduce cost, and shorten development cycles. The interesting question in this context is: How to achieve reuse in constrained environments? In desktop and enterprise systems, object-orientation, components, frameworks, service-oriented architectures and, most recently, model-driven development are proposed as cornerstones for efficient reuse. In constrained environments (i.e. embedded and real time systems, PDAs, smart phones, settop boxes) reuse is not as simple, because most reuse techniques imply some kind of overhead: memory, performance, or determinism.

This workshop explores practical reuse techniques for constrained environments. Potential topics include, but are not limited to:

• middleware technologies
• quality of service provisions
• code composition and weaving
• code generation, composition and weaving
• small and efficient frameworks
• component infrastructures for embedded systems
• model driven development
• static variability and metaprogramming
• component composition
• design and architectural patterns

http://www.voelter.de/conferences/oopsla03.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

Reengineering and evolution are important for long-lived software systems. Change and growth in the system's requirements and functionality occur in all kinds of systems — and it is especially critical to manage the evolution process in modern agile and extreme software processes. The management of change and growth may in fact become a daily activity, so a well defined set of techniques and tools for doing reengineering are critical to success.

This workshop picks up from the results of the OOPSLA '02 workshop "Tackling the Discovery Costs of Evolving Software Systems."

Participants will present and discuss encapsulation and reverse engineering techniques, impact of reengineering on software processes, organizational concerns, and experiences in managing software change "in the extreme".

http://csc.noctrl.edu/f/opdyke/OOPSLA2003

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:

• End-users of the solution who will have to live with the solution and will ultimately decide how successful it is – often they are external customers of the company
• The Enterprise that is hoping to realize a business ROI from the solution
• IT departments or other technical organizations responsible for implementing the solution
• Technology vendors whose technology provides underpinnings and components of the solution

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:

• Improved likelihood of project success
• Increased enterprise vitality through effective use of technology
• Greater ROI of technology spending

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 objective of this workshop is to have a detailed technical discussion on requirements for future virtual machines and advanced languages from an applications perspective.

Issues such as what features and their virtual machine implementations actually promote object reuse. What has worked in the past? Has the original design goals of the respective participants in their respective object architectures been met. What problems were encountered during the commercial deployment of their respective architectures? What do the participants see as the direction they believe that virtual machine technology will take in the near future, as well as over the long haul?

http://www.aurorasoft.net/workshops/lar03/lar03home.htm

Web services and service-oriented architectures are promising technology. However, they are still fraught with problems and issues: operational issues, quality of service, functional and methodology related.

In this workshop we aim to identify real industry experiences (successes or failures) in designing and implementing web services based systems. And we look for research papers aiming at identifying and alleviating major bottlenecks and issues related to service-oriented architectures, web services and dynamically re-configurable architectures.

This workshop builds on the Object Oriented Web Services workshops in previous OOPSLA conferences and sets a slightly different direction, aimed at consolidating web services and service-oriented architecture best practices and patterns.

http://www.arsanjani.com/oopsla2003/webservices.htm

This tutorial gives an in-depth overview of the C# programming language, both as it currently exists and as it is planned to evolve in the near future. An emphasis will be placed on explaining design rationales, making the talk interesting for both programmers and language designers.

Attendee background

Prerequisites: Participants should have a good working knowledge of object-oriented programming. Previous experience with C# and .NET is not required.

Format

Lecture and working code demonstrations

Presenter

Anders Hejlsberg is a Distinguished Engineer in the Developer Division at Microsoft Corporation. He is the chief designer of the C# programming language and a key participant in the development of the .NET Framework. Before joining Microsoft in 1996, Anders was a Principal Engineer at Borland International. As one of the first employees of Borland, he was the original author of Turbo Pascal and later worked as the Chief Architect of the Delphi product line. Anders studied Engineering at the Technical University of Denmark.

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 background

Prerequisites: Sound knowledge of the pattern concept and the GoF patterns are required.

Format

Interactive lecture

Presenters

Frank Buschmann is senior principal engineer at Siemens Corporate Technology in Munich, Germany. His interests include Object Technology, Frameworks and Patterns. Frank has been involved in many software development projects. He is leading Siemens' pattern research activities. Frank is co-author of "Pattern-Oriented Software Architecture -- A System of Patterns" and "Pattern-Oriented Software Architecture -- Patterns for Concurrent and Networked Objects".

Kevlin Henney is an independent consultant and trainer. The focus of his work is in programming languages, OO, CBD, UML, patterns, and software architecture. He is a regular columnist for C/C++ Users Journal (online), Application Development Advisor (UK), and JavaSpektrum (Germany), and previously wrote columns in Java Report and C++ Report. He is also a member of the advisory board for Hillside Europe, the program chair for EuroPLoP 2003, and a popular speaker at conferences in the US and Europe.

The last decade or so has been one of technology churn. We've seen client/server, CORBA, J2EE, COM, .NET and a host of other enterprise platforms appear or fade from view, or both. Keeping up with resulting alphabet soup is a full time job, even without applications to ship.

But amongst all of this churn, some techniques stay relatively constant. So we've been trying to identify these common patterns and taking note of how we use the ideas from one technology and use similar, but not the same designs in others.

In this tutorial, we'll explore a number of these patterns. We will touch on various topics, including layering, business logic organization, database mapping, organizing a web interface and the allure of distributed objects.

The tutorial is based on the author's book, "Patterns of Enterprise Application Architecture."

Attendee background

Prerequisites: Participants must be familiar with the basics of object-oriented development in an enterprise setting.

Format

Lecture

Presenter

Martin Fowler is the Chief Scientist of ThoughtWorks, a systems delivery and consulting firm. He has pioneered the use of object-oriented technology in enterprise applications and has written five books on software development.

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 background

Prerequisites: Attendees should have a basic understanding of what a pattern is. No prior knowledge in any specific domain is expected. Attendees will gain the most from the tutorial if they have considered the general performance and reliability constraints with which they most frequently work.

Format

Lecture

Presenter

Robert Hanmer is a Consulting Member of Technical Staff in the Convergence Solutions R&D organization of Lucent Technologies. He began working with patterns in 1995, capturing the patterns of a large telephone switching system and also of telecommunications systems in general. He has served as Program Chair at several PLoP conferences. He is active in the Hillside Group, as well as the TelePLoP group, which is an informal collection of pattern advocates and authors interested in the field of telecommunications. He has authored many patterns that discuss key solutions for high performance systems.

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 background

This tutorial is intended for enterprise application architects, designers, and developers who have basic familiarity with messaging tools and technologies, but wish to learn how best to use messaging to achieve enterprise application integration, and wish to be able to better communicate about these issues.

Prerequisites: Basic familiarity with messaging tools and technologies.

Format

Lecture

Presenters

Bobby Woolf has been developing multi-tier object-oriented business applications for thirteen years using Java/J2EE, Smalltalk, and embedded systems for messaging, workflow, business rules, and persistence. One of his specialties is developing architectures that integrate workflow, EJB, and JMS. He has presented tutorials at OOPSLA and JavaEdge, published articles in Java Developer's Journal and on the DeveloperWorks web site, published patterns in all of the PLoPD books, and is a co-author of The Design Patterns Smalltalk Companion. He is also a co-author of the upcoming book "Enterprise Integration Patterns" from Addison-Wesley.

Gregor Hohpe leads the Enterprise Integration Services competency at ThoughtWorks, Inc., a provider of application development and integration services. Over the past years, he has been helping clients around the globe design and implement enterprise integration solutions. His current work focuses on the application of agile methods and design patterns to the development of integration solutions. Gregor is a frequent speaker at technical conferences and has published a number of articles presenting a no-hype view on enterprise integration, Web services and Service-Oriented Architectures. He is a co-author of the upcoming book "Enterprise Integration Patterns."

Dealing with the complexity of large-scale systems can be a challenge for even the most experienced software designers and developers. Large software systems can contain millions of elements, which interact to achieve the system functionality. Managing and representing the complexity involved in the interaction of these elements is a difficult task.

This tutorial will help you manage this complexity through the use of industry-proven software architecture approaches, based on the UML and IEEE 1471 standards. We will introduce software architecture terminology and approaches, focusing on a set of UML viewpoints that represent the important aspects of a large-scale software architecture. These viewpoints include context, component, subsystems, process and deployment. These viewpoints leverage the recent IEEE 1471 standard for software architecture representations providing a description of the purpose, stakeholders, and techniques associated with each viewpoint.

The tutorial also presents other practical techniques essential to developing an effective software architecture. Topics covered in the tutorial include:

• Techniques for handling large, complex systems
• Modeling of software subsystem interfaces and dependencies
• Modeling of components, component interactions, and component integration
• Modeling of process communication and software/hardware deployment
• Fitting architecture development into development processes

Attendee background

Prerequisites: Attendees must have a basic understanding of UML, have experience as a software developer, and an interest in software architecture. Experience on a large-scale software system is beneficial but not required.

Format

Lecture and discussion

Presenters

Jeff Garland has worked on many large-scale software projects over the past 16 years, and in many different domains, including telephone switching, industrial process control, satellite ground control, and financial systems. He has served as both the lead architect and a member of the architecture team on several of these projects. Mr. Garland holds a Master's degree in Computer Science from Arizona State University and a Bachelor of Science in Systems Engineering from the University of Arizona. He is currently President and Chief Technology Officer of CrystalClear Software. CrystalClear Software is a consulting firm that specializes in the development of software architectures for large-scale systems.

Richard Anthony has l7 years experience working on large-scale software development efforts. The systems are from application areas such as satellite and network operations systems, telephony base station control, manufacturing, and simulation. He has served in the role of chief software architect, design engineering technical lead, software design lead, software system engineer, and developer on projects in these application areas. Mr. Anthony holds Master's degrees in Computer Science and Mathematics, as well as a Bachelor's degree in Mathematics Education, all from the University of Wyoming. He is currently a Senior Software Architect at General Dynamics Decision Systems.

So you're a technical lead. You will have to combine many disparate skills to achieve that elusive goal, the successful team. Project management, people management, requirements management, as well as good design and implementation skills, are all core ingredients. This tutorial examines techniques and patterns for being a successful technical lead. Key areas covered include:

• Becoming a technical lead (leadership styles, winning respect etc).
• Project initiation--laying down the foundations, selecting a method.
• Getting decisions adopted and socialised.
• Targeted design and architecture.
• Transparent design.
• Managing upwards--metrics, monitoring progress, etc.
• Handling personnel problems.
• Handling a project in crisis.
• Worry Patterns--signs not to be ignored.

...and more. A recent project will be used to illustrate the application of the techniques "in the wild." During the tutorial, there will be time to share experiences, discuss problems and consider other solutions. Participants will leave with a comprehensive set of references.

Attendee background

Participants will be either new to technical leadership or already have been in a technical lead role for some time and wish to share experiences and learn some new techniques.

Format

Lecture, group discussion, and copious real world examples

Presenter

Andy Schneider wears consultant and architect hats for BJSS, a software services organisation. He has been involved in implementing, designing and leading projects utilising object-oriented technology since 1990. His primary interests are complex distributed systems, security and technical management. When wearing his consultant hat, he finds himself performing presentations and tutorials on a regular basis.

Large information systems need a domain model. Development teams know this, yet they often end up with little more than data schemas. This tutorial delves into how a team, developers and domain experts together, can engage in progressively deeper exploration of their problem domain while making that understanding tangible as a practical software design. This model is not just a diagram or an analysis artifact. It provides the very foundation of the design, the driving force of analysis, even the basis of the language spoken on the project.

The tutorial will focus on three topics:

1. The conscious use of language on the project to refine and communicate models and strengthen the connection with the implementation.
2. A subtly different style of refactoring aimed at deepening model insight, in addition to making technical improvements to the code.
3. A brief look at strategic design, which is crucial to larger projects. These are the decisions where design and politics often intersect.

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.

Attendee background

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.

Format

Interactive reading/discussion session, and simulations of the activities and processes that go into making domain design decisions.

Presenters

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.

Attendee background

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.

Format

Lecture and interactive discussion

Presenter

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.

Software engineering education for working professionals remains a challenge from the perspective of determining relevant content; identifying effective methods for delivery; and maintaining the focus and motivation of students. This panel brings together academic and industry professionals to share their perspectives and experiences. Anticipated points for discussion include: education/training delivery strategies, curriculum definition, marketing issues, collaboration strategies to engage industry sponsorship, value assessments for students and sponsoring organizations, and program success stories. This will be a highly interactive panel and the audience should come prepared to both ask and answer questions.

This demo shows Smart Play-Out, a new method for executing and analyzing scenario based behavior, which is part of the Play-In/Play-Out methodology and the Play-Engine tool. Behavior is "played in" directly from the system's GUI, and as this is being done the play-engine continuously constructs Live Sequence Charts (LSCs), a pow