Tutorials

Tutorials are the centerpiece of OOPSLA's educational program. This year, OOPSLA offers you 48 tutorials to choose from. Each tutorial is half-day in length and taught by experts in their respected fields. No matter your level of expertise; there are tutorials targeted for all levels of participants. Tutorials cover the range from best pracitces in standard technologies and methodologies to new ideas that may change how we develop software in the coming years.

Refactoring of Software Architecture - Principles and Patterns (Tutorial 1)

Abstract

In agile settings the development of software systems should follow a piecemeal growth where engineers refine the software architecture step by step until the system is complete. Unfortunately, "nothing is permant except change" (Heraclitus). Hence, a top-down approach would only work if all requirements are complete and consistent from day 0, and architects and developers make no mistakes. In practice, change is the rule, not the exception. Same for "errare humanum est". Not systematically coping with change leads to software systems that are hard to maintain due to increased entropy. It is not sufficient to add parts in each step of architecture design. Instead, we should clean up before any further refinement. Existing literature broadly covers code refactoring. However, refactoring activities are also applicable to other artifacts, especially to software architecture. The tutorial introduces the foundation of software architecture refactoring. It illustrates how to leverage architecture refactoring in a development process. But it also presents its limitations. For example, it explains when reengineering might be a better option. While the first part focuses on the principles of software architecture refactoring, the second part introduces a catalog of architecture refactorings that should be in the toolbox of any software architect.

Objectives

Understanding refactoring as a fundamental principle of software design Understanding the differences between software architecture refactoring and reengineering Learning a toolbox of refactoring patterns

Tutorial History

This tutorial has bee given at OOPSLA 2007. It has been significantly changed and improved according to attendee feedback. It also has been reviewed within Siemens in the context of a senior software archiect certification program.

Audience:Researchers, Practitioners, Educators

Format:Interactive Powerpoint presentations with a small exercise

Classification:Several Areas

Presenters

Marwan Abu-Khalil
Marwan Abu-Khalil is a senior software architect at Siemens Corporate Technology in Michael Stal's team. He is a consulting specialist for the industry sector. His main research interests include distributed and concurrent systems. He also gained broad experience working as an architect for airline software at Lufthansa-Systems. Marwan holds a master in mathematics and a master in computer science. He has been a conference speaker on enterprise architectures for Java and .Net.

Michael Stal
Dr. Michael Stal is a Principal Engineer and Team Lead at Siemens AG where his research and consulting activities focus on Software Architecture and Distributed Systems. He is co-author of the book series Pattern-Oriented Software Architecture as well as of several other publications. In addition, he was appointed Microsoft MVP Solution Architect and serves as editor-in-chief of the german JavaSPEKTRUM magazine since 1996. Michael also has been a frequent speaker at various international events.

Architecture As Language (Tutorial 2)

Abstract

Software Architecture is often either imprecise and hard to grasp or technology specific. What you really want is a succinct, precise, technology-independent and tool-processable description of an architecture. In this tutorial we illustrate how textual DSLs can be used to this end. The core idea is to actually develop an architecture language as you understand the architecture, formalizing the growing intuitive understanding into a formal language. This removes ambiguity from the discussion, requires answers to arising questions and results in a more consistent and (re-)usable architecture. The tutorial has three parts: we start with a role play where we showcase how an architecture DSL is developed as part of a discussion about a system's architecture. We actually build an example DSL in real time. In part two we look at some of the concepts, rationales and benefits of the approach, and briefly point to tools that can be used to build languages and associated tooling. The third part looks at how to use the approach for product lines: how to express variability in the architectural descriptions, and how to integrate the DSL with feature-modeling based variability management. The tutorial is for practitioners, by practitioners. It is guaranteed to contain only practice-oriented material.

Objectives

Goals 1. Demonstrate how architecture-specific DSLs are used for easing the definition of the architecture of a platform or product line 2. Convince people that this kind of approach is especially effective for large systems, platforms and product lines and hence 3. Provide enough material and pointers to the audience so they can actually use this approach in practice (basically pointers to tools) Background The tutorial will cover the material described in [1] and [2]. Architecture in general suffers from the following problems: o It is hard to describe architecture in a way that is unambiguous and concrete, yet technology-independent. (As a consequence, often architecture is a set of documents or Wiki pages) o Focusing on technology instead of the architectural concepts is bad because it creates unintended dependencies on the technologies. o Programming languages are not suitable to describe architecture, since they lack the necessary means to express architectural concepts (e.g. components or ports) as first class entities. In product lines, these problems are even worse, since o technology independence is even more important because of the typically long lifetime of platforms and product lines o not describing an architecture concretely makes it very hard to understand it well enough to reuse components efficiently (i.e. not spending a lot of time to understand how the component fits into the product architecture) o and finally, we also need to describe variations in the solution space and their dependency on features (or something similar) in the problem space. The approach explained in the tutorial solves all those problems by providing a formal language for describing the architecture. Such a language is specific to the architecture to be described, developed as we understand the architecture. The language is independent of technologies. Because the language is specific to the architecture being built, it supports first class the concepts found in the architecture. Based on this DSL, you can express variations between the products by including feature-dependent sections in the model. Composition of reusable components in different products is facilitated through their formal description in the models. Note: it is hard to explain all the reasoning in two pages. You might want to consider reading [1] and [2]. We will execute this tutorial as a "role play" where Christa and Iris will play the role of the customer who wants to build a product line. Markus will play the role of the consultant who helps the customer use the DSL approach for building the system. We will interactively construct the actual DSL and hence illustrate that this is a feasible and very useful approach. Note that the tutorial will not cover in detail how to actually work with the DSL tooling and how to build generators. Both of these topics will be briefly mentioned, and we provide pointers to additional material for the participants to read. [1] Markus Voelter, Architecture As Language Pt. 1, http://www.voelter.de/data/pub/aal/ArchitectureAsLanguage-PDF.pdf [2] Markus Voelter, Architecture As Language Pt. 2, http://www.voelter.de/data/pub/aal/ArchitectureAsLanguage-Part2-PDF.pdf

Tutorial History

This tutorial is new.

Audience:Practitioners

Format:The tutorial will be executed partly as a role play and partly slide-based. The role play will showcase the story parts of [1] and [2] and will use live coding by the presenters. The slide-based parts will explain the conceptual aspects in the second parts of [1] and [2].

Classification:Practice

Presenters

Markus Voelter
Markus works as an independent consultant and coach for software technology and engineering. He focuses on software architecture, model-driven software development and domain specific languages as well as on product line engineering. Markus is (co-) author of many magazine articles, patterns and books on middleware and model-driven software development. He is a regular speaker at conferences world wide. Markus can be reached at This e-mail address is being protected from spambots. You need JavaScript enabled to view it or via www.voelter.de

Green Bar for C++: Test-driven Development and Refactoring for C++ (Tutorial 3)

Abstract

Automated unit testing supports high quality of program code, even under inevitable change and refactoring. As a side effect, unit tested code often has a better structure and modularity. Test-Driven Development (TDD) uses unit tests written prior to production code and continuous refactoring as a means to better designed code. So far C++ programmers lacked the tool support for easy-to-use unit testing and refactoring, even though the language's complexity asks for it. Refactoring and simplifying C++ code without tests is hazardous. This tutorial introduces C/C++ programmers to refactoring and TDD with the unit testing framework CUTE(C++ Unit Testing Easier). The job of retro-fitting automated tests to an existing code base is also addressed. CUTE will be used with a corresponding Eclipse CDT plug-in with support for automatic navigation to failing test cases. IFS Institute for Software also implemented the C++ refactoring extension, that is now integrated into Eclipse CDT's Ganymede release. Detailed instructions on how to prepare your own laptop will be given at http://wiki.hsr.ch/PeterSommerlad/wiki.cgi?OopslaCuteTutorial or provided on site. The CUTE framework will also work with MS VisualStudio but without refactoring or test run visualization.

Objectives

You will learn and exercise to write unit tests for C++ code and refactor your code and tests. Advanced unit testing techniques such as TDD and means to retrofit unit tests to existing code are taught and exercised

Tutorial History

Was presented similarly (without focus on TDD) with great success at OOPSLA 2007. The presenter uses CDT and CUTE in his C++ lectures and exercises.

Audience:Practitioners, Educators

Format:Bring your own laptops with Eclipse-CDT (Ganymede Release) pre-installed! Lecture, life-programming on large screen plus active programming exercises to be worked on by participants.

Classification:Practice

Presenters

Peter Sommerlad
Peter Sommerlad is professor for software engineering and head of Institute for Software at HSR Hochschule f. Technik, Rapperswil. Peter is co-author of the books Pattern-oriented Software Architecture Vol.1 and Security Patterns as well as author and shepherd of many other patterns for software and security. His current research interests are in refactoring for non-java languages in Eclipse (e.g. C++, Ruby, groovy, JavaScript, Python) with his long-term goal of making software simpler by decremental development: Refactoring software to 10% its size with better architecture, testability and quality and even improved functionality.

Software 'Best*' Practices: Agile Deconstructed - *Context Matters! (Tutorial 4)

Abstract

This tutorial is an introduction to software best practices. While many of these best practices have been incorporated into agile methodologies, this presentation does not promote a specific agile methodology.

Objectives

Share experience and provide context/information on: 1) What is a software "best practice" (primary) 2) Software "best practices" and related constraints (primary) 3) Ongoing research in the area of "software best practices" (secondary)

Tutorial History

The Tutoral was run at OOPSLA 2007 in a 1/2 slot (to accommodate the the last minute addition of David Parnas to the OOPSLA 2007 program). Registrations exceeded 30 - and there were over 45 attendees with walk-ins including students. Tutorial has been given internally at Qualcomm (2007) and Cisco (2008). Tutoral material has been dervived from previous tutorials, workshops and panels at XP200N, OOPSLA, and practical experience at Nortel, Qualcomm, and Cisco.

Audience:Researchers, Practitioners, Managers, Educators

Format:Lecture, discussion, and shared experiences.

Classification:Practice

Presenters

Steven Fraser
Steven Fraser recently joined Cisco Research in San Jose, California as a Director (Engineering). Previously, Steven was a member of Qualcomm's Learning Center in San Diego, California with responsibilities for technical learning. Steven also held a variety of technology management roles at BNR and Nortel including: Process Architect, Senior Manager, and Design Process Engineering Advisor. In 1994 he spent a year as a Visiting Scientist at the SEI at CMU collaborating on the development of team-based domain analysis (software reuse) techniques. Fraser was the General Chair for XP2006 and is the Corporate Support Chair for OOPSLA'08 and Tutorial Chair for both XP2008 and ICSE 2009. Fraser holds a doctorate in EE from McGill University in Montréal - and is a member of the ACM and a senior member of the IEEE.

iPhone SDK a kickstart - Using Xcode 3.1 Developer Tools for iPhone OS 2.0 (Tutorial 7)

Abstract

iPhone is a pretty new device that involve several technologies (phone, video, audio, images, and web among others). This gadget, the best in 2007 year according to Times Magazine, has captive the interest of different types of users and created a new emerging market in various environments. Today thousands of programmers want to provide applications on the iPhone. Apple recently released the iPhone SDK (March 2008) toolkit. Using XCode 3.0 under Mac OS X 10.5 as our IDE, and Objective-C and iPhone API as our programming tools we will create iPhone applications (from basic to medium level) which finally can be load into an iPhone. We'll start with the classical 'Hello World' and continue to develop applications using graphical user interfaces, handling multi-touch and detect motion, communication with web application, and different media.

Objectives

Through this tutorial, the attendee will: o Learn about iPhone software architecture. o Learn about iPhone Development tools and Objective-C programming language. o iPhone Application Framework o Graphics and Media Overview o User Interface Design and Key practices for iPhone Applications o Location, Acceleration, Orientation and System Information o Fundamentals of iPhone for Web Developers

Tutorial History

This is a new tutorial.

Audience:Practitioners, Educators

Format:After a brief introduction about iPhone software architecture and iPhone SDK developing toolkit, participants will work on hands-on exercise. Users will develop an applications and try it into iPhone simulator, and/or if possible into an iPhone physical device. In order to take the most advantage of this tutorial it is desirable that attendees bring their own laptop.

Classification:Practice

Presenters

Javier Gonzalez-Sanchez
Javier is professor at Tecnológico de Monterrey, campus Guadalajara since January 2000 and program chair of B.S. Computer Science and Technology program since 2006. Javier got his master degree in Computer Science by Instituto Politecnico Nacional in Mexico. He is a developer, project leader and consultant, working with private companies and public institutions, making analysis, design, re-engineering and implantation of computational systems and web applications. Areas of interest: distributed and parallel computing, data bases, Web services, software architecture and modeling. Member of Association Computing Machinery (ACM) since 2002. His publications include topics in: anti-patterns, visual programming environments and distributed systems. He has been participating as speaker and workshop organizers in areas such as Java2 ME, Web development (php, J2ee), Software Architecture among others. More about him at www.javiergs.com

Maria Elena Chavez-Echeagaray
Maria Elena (Helen) is full-time teacher at Tecnologico de Monterrey, campus Guadalajara since January 2001. Helen got her master degree in Computer Sciences by Tecnologico de Monterrey campus Guadalajara. Areas of interest: programming, software engineering, data bases and networking. Member of the Association Computing Machinery (ACM) since 2000. Participate as staff member at Object Oriented Programming, Systems, Languages, and Applications (OOPSLA) as staff member (volunteer) at '98, '99, '00, '01, '02, '05. She has participated as workshop organizer in different workshops in different conferences organized by the university.

Introduction to Web Technologies (Tutorial 8)

Abstract

While the web has become ubiquitous, even extensive experience using a browser does not guarantee that an otherwise talented developer understands how to design applications for the web. As developers turn from traditional N-tiered or fat-client applications to the web, there are various architectural issues that need to be understood. As you move into this exciting new arena, you might be asked to evaluate a framework based on its ability to handle RESTful URLs or you might be asked whether state should be carried in hidden fields or in a session cookie. If you are hearing buzzwords that you don't understand and want to catch up with this rapidly-changing area, then this tutorial is for you! We will start with some history to see how some early factors influenced the challenges and decisions being made today. Then we will look at various general approaches to the various challenges of the web. Finally, we will look at how some popular (and not-so-popular but innovative) frameworks address these challenges.

Objectives

Participants will understand the limitations existing in the various web technologies and be able to recognize and judge the trade-offs made by various applications and frameworks to work around these limitations.

Tutorial History

Presented at Smalltalk Solutions 2004 in Seattle.

Audience:Practitioners, Managers

Format:Lecture with slides

Classification:Practice

Presenters

James Foster
As a junior-high student in 1971, James discovered the local university's computer lab and learned Basic, Fortran, and assembly. After trying other careers (commercial aviation and law), he returned to computer programming and was introduced to OOP on the Macintosh in the 1980s. Since then James has worked on large system (primarily in healthcare) and introduced agile practices to the teams he has lead. James is a veteran OOPSLA attendee and has presented at OOPSLA and other conferences. James Foster is on the Smalltalk Engineering Team at GemStone Systems, Inc. and has been an evangelist for the Seaside web framework.

Textual DSLs - Concepts and Tooling (Tutorial 9)

Abstract

Domain Specific Languages are becoming important ingredients of software developers' tool chests. The mainstream is divided into two camps: external graphical DSLs (aka Modeling) and internal textual DSLs (via meta programming in languages like Ruby). As experience shows however, a sweet spot for DSLs is textual external DSLs: you can define any grammar you want, you can have domain specific constraint checks and error messages, and processing models is straight forward: generate code or interpret them based on the AST derived from the grammar. Another advantage - especially compared to graphical DSLs - is that they integrate natively with today's development infrastructure (CVS/SVN diff/merge). In this tutorial, I introduce DSLs in general, talk about advantages of textual external DSLs and explain how the Eclipse Xtext tool is used to develop editors for your custom DSLs that resemble modern IDEs with features such as syntax coloring, code completion, real-time constraint checking, customized outlines and inter-file navigation. I will also discuss how to process the models created with the editor. The goal is to provide you with all the concepts, tooling and pointers you need to build your own textual DSLs in a way that is efficient enough for practical project reality.

Objectives

Model-Driven Development and DSLs is clearly a useful technique for software engineering. The ability to describe and analyse aspects/concerns/viewpoints of systems in a formal language that is processable by tools in a great advantage when building systems. One could even argue it is the essence of software development: describing something formally and then systematically and automatically transforming it into executable code. One of the biggest barriers to adoption of the approach (except the traditional skepticism that objects any new development) are tool integration issues. It is challenging to integrate a large and bloated UML tool, a non-standard-conforming proprietary modeling tool or anything that stores its data in repositories. Using textual DSLs completely removes this problem. Human-readable models are stored, versioned, searched and diffed like any other text file, naturally integrating with CVS and SVN. Also, we know from working with traditional source code that text is a useful representation for even large systems. Of course there's nothing revolutionary about building domain specific, custom or "little" languages. Tools to do so have been around since the dawn of programming, they are called parser generators. Contemporary examples include JavaCC or antlr. However, defining a language and implementing a parser for it is not enough these days. People are used to working with powerful IDEs like Eclipse, Visual Studio or IntelliJ. So, to make textual DSLs a real alternative, we need a editors that provide similar features than contemporary IDEs. syntax color, code completion, outlines, cross-referencing (go to definition/find references), navigation across multiple files, various outline views and other tree-like displays of relationships between elements. This is what this tutorial is about: with tooling such as openArchitectureWare Xtext/Eclipse TMF it is feasible to build editors that resemble Eclipse JDT in their feature set for your own custom DSL. Coming up with a first cut at the editor is literally a matter of minutes. Customizing code completion and providing additional outlines can be done in a couple of hours. Also, once you have built the editor, the infrastructure makes sure that the textual models you create with it are parsed into an EMF model - in other words, allowing you to process the model with any of the dozens of EMF-based model validation, transformation and code generation tools available for EMF at Eclipse and elsewhere. Experience shows that this kind of tooling might be the killer application for MDSD. Whenever I talk about MDSD somewhere, people are intrigued by what Xtext can do for them. Most developers naturally see the potential of custom languages and tool-based processing of models. But they are skeptical about the "picture drawing" and tool integration nightmare. Textual DSLs completely remove those fears, while preserving the advantages of MDSD and DSLs. As you can see from the text above I am fairly passionate about this. I really do think that every developer should know how to build languages - and process the sentences with tools. The approach presented in this tutorial makes this approach a practical reality. So here is what I want the audience to take away: o Understand the value of formalizing aspects of software systems into languages o Learn how textual languages are suitable for many more modeling tasks than people might think (often, modeling is equated to drawing diagrams) o Learn how to build editors for custom DSLs with Eclipse/oAW tooling o and finally, learn how to process those models

Tutorial History

This tutorial is new.

Audience:Practitioners

Format:Partly slide show, partly live coding by the presenter.

Classification:Practice

Presenters

Markus Voelter
Markus Voelter works as an independent consultant and coach for software technology and engineering. He focuses on software architecture, model-driven software development and domain specific languages as well as on product line engineering. Markus is (co-) author of many magazine articles, patterns and books on middleware and model-driven software development. He is a regular speaker at conferences world wide. Markus can be reached at This e-mail address is being protected from spambots. You need JavaScript enabled to view it or via www.voelter.de

Peter Friese
Peter Friese is a software architect for itemis in Kiel. He is a committer for the open source projects openArchitectureWare, Eclipse, FindBugs, and AndroMDA. As a software engineer and software architect, Peter has worked on a variety of industry projects in different domains such as banking, aerospace and transport. Peter is the author of various articles on the topics of Eclipse, Spring, and model-driven software development and gives lectures on these themes at software conferences.

Bernd Kolb
Bernd Kolb focuses on model-driven software development and Eclipse technologies. As a consultant, he has worked in different domains from tooling for automotive embedded systems to enterprise Java applications. He is a regular speaker at conferences and has written a number of articles as well as co-authored a book. He can be reached at www.kolbware.de.

Understanding Security with Patterns (Tutorial 10)

Abstract

According to security guru Bruce Schneier, security is all about trade-offs you take with respect to your always limited resources. Today, security is often a problem either when designing a system or-in the worst case-as an after-thought. Only a few experts have knowledge to design good security and we can safely assume that there is no security expert in most development teams. Before Design Patterns OO-design was a similar black art only performed well by experts. We expect Security Patterns to provide such leverage for designing secure systems, because they make discussions easier with the common names for concepts, make security design decisions more conciously, and because they tell the truth about their trade-offs. This tutorial introduces the work on security patterns as given in the book Security Patterns - Integrating Security and Systems Engineering: * Why is there a need for Security Patterns? * What is behind Security Terminology? * What is a Security Patterns? * Selected Security Patterns examples with some exercises from different security relevant areas The exercises help to develop security awareness between technical and non-technical project stakeholders. Other patterns presented show design and architecture relevant for implementing security.

Objectives

you will learn about security patterns that can give you a better understanding and vocabulary of security design.

Tutorial History

OOPSLA 2006 and several other venues in varying lengths. Advanced Patterns lecture of presenter uses parts of this tutorial.

Audience:Practitioners, Managers, Educators

Format:lecture style with a few exercises (about 5-10 minutes each) for the audience to solve and discuss in small groups.

Classification:Educational

Presenters

Peter Sommerlad
Peter Sommerlad is professor for software engineering and head of Institute for Software at HSR Hochschule für Technik, Rapperswil. Peter is co-author of the books Pattern-oriented Software Architecture Vol.1 and Security Patterns as well as author and shepherd of many other patterns for software and security. His current research interests are in refactoring for non-java languages in Eclipse (e.g. C++, Ruby, Groovy, JavaScript, PHP, Python) with his long-term goal of making software simpler by decremental development: Refactoring software to 10% its size with better architecture, testability and quality and even improved functionality.

Programming LEGO ® Mindstorms with Java. (Tutorial 11)

Abstract

LEGO ® Mindstorms ® robots can do more than you ever expected. How to get in there?. The answer is combining the LEGO Mindstorms cool and fun hardware with the power of the Java platform--the world's hottest programming technology.

This tutorial will show you how to get in, step by step. We'll start with the basics and then we'll teach you techniques to control LEGO ® Mindstorms ® robots. This tutorial will teach you how to build robots combining intelligence and power. We will cover:

1. Installing LeJOS, the Java Virtual Machine designed for the LEGO Mindstorms programmable controller

2. Setting up your Java platform development environment for LEGO Mindstorms

3. Programming rotation and custom sensors.

4. Using behavior control programming

5. Gathering map data and transmitting it back to your computer

Objectives

Through this tutorial, the attendee will: o Learn about programming tool: LeJOS (Lego and Java). o Show, discuss and enhanced several examples using LEGO ® Mindstorms o Robot behavior o Robot navigation o Robot communication o Overview of Vision and Speech

Tutorial History

This tutorial has been presented in different local forums in the last year.

Audience:Educators

Format:After a brief introduction about Lego technology and LeJOS, participants will work on hands-on exercises. Users will develop these exercises, in order to review, evaluated, an enhanced those exercises.

Classification:Educational

Presenters

Javier Gonzalez-Sanchez
Javier is professor at Tecnológico de Monterrey, campus Guadalajara since January 2000 and program chair of B.S. Computer Science and Technology program since 2006. Javier got his master degree in Computer Science by Instituto Politecnico Nacional in Mexico. He is a developer, project leader and consultant, working with private companies and public institutions, making analysis, design, re-engineering and implantation of computational systems and web applications. Areas of interest: distributed and parallel computing, data bases, Web services, software architecture and modeling. Member of Association Computing Machinery (ACM) since 2002. His publications include topics in: anti-patterns, visual programming environments and distributed systems. He has been participating as speaker and workshop organizers in areas such as Java2 ME, Web development (php, J2ee), Software Architecture among others. More about him at www.javiergs.com

Maria Elena Chavez-Echeagaray
Maria Elena (Helen) is full-time teacher at Tecnologico de Monterrey, campus Guadalajara since January 2001. Helen got her master degree in Computer Sciences by Tecnologico de Monterrey campus Guadalajara. Areas of interest: programming, software engineering, data bases and networking. Member of the Association Computing Machinery (ACM) since 2000. Participate as staff member at Object Oriented Programming, Systems, Languages, and Applications (OOPSLA) as staff member (volunteer) at '98, '99, '00, '01, '02, '05. She has participated as workshop organizer in different workshops in different conferences organized by the university.

Building Service-Oriented Architectures with Web Services (Tutorial 12)

Abstract

Service-Oriented Architecture (SOA) and Web services technologies have matured into highly attractive architecture and implementation alternatives for building distributed systems. SOA concepts and Internet protocol-based implementation stacks are a powerful combination that is well-suited for crafting heterogeneous business-to-business and enterprise application integration solutions. In this tutorial, we introduce SOA as an architectural style defined by patterns such as Enterprise Service Bus (ESB) and service composition. We present two industry case studies that demonstrate where and how these patterns can be applied in practice. Next, we present selected elements of the Web services technology standards stack from an application programmer's perspective, for example SOAP and WSDL. In a third module, we design and develop a complete sample application applying the introduced concepts and technologies, making use of the Web services editors and code generators in the Eclipse Web Tools Project (WTP). We conclude with a discussion of the key architectural decisions on SOA and Web services development projects - for example REST vs. SOAP message exchange; service interface creation process and granularity concerns; security, reliability and other quality-of-service factors; server-side deployment and client-side invocation guidelines. This discussion centers around the lessons learned on large-scale industry case studies.

Objectives

The tutorial is aimed at software architects wanting to design end-to-end SOAs and developers wanting to develop and deploy Web services requestor and provider applications. Attendees will develop an understanding of the principles and patterns defining SOA as an architectural style, will learn how to leverage open source tools to create Web services descriptions, server-side stubs, and client-side invocation proxies for several languages, and will know the key architectural decisions required on SOA and Web services projects.

Tutorial History

This tutorial is an updated version of OOPSLA 2005, 2006, and 2007 tutorials.

Audience:Researchers, Practitioners, Educators

Format:Slide-based lecture, amended with several exercises and practical demonstrations illustrating the design and development steps for a sample scenario. We will start with architecture overview diagrams and then drill down to UML and code level of precision and detail.

Classification:Practice

Presenters

Olaf Zimmermann
Olaf Zimmermann is a research staff member at the IBM Zurich Research Lab. Olaf is an Open Group Master certified and IBM senior certified executive IT architect. His research focuses on using architectural decisions models to support collaborative SOA construction activities. Previously, Olaf was a solution architect, helping IBM clients design enterprise-scale SOA/Web services and Java 2 Enterprise Edition (J2EE) solutions on numerous service projects. He has also educated practitioners around the world on emerging middleware technologies. At the beginning of his career, Olaf worked as a scientific consultant at the IBM European Networking Center (ENC) in Heidelberg, Germany. He is a regular conference speaker and an author of the Springer textbook Perspectives on Web Services. Olaf holds a graduate "Diplom-Informatiker" degree in computer science from the Technical University in Braunschweig, Germany.

The Art of Telling Your Design Story (Tutorial 13)

Abstract

Do you have trouble communicating design ideas, getting buy-in to new approaches, or informing others about your design? The best way to present your design isn't the same way you came up with it. As Francis Galton, a 19th century geneticist remarked, "It often happens that after being hard at work, and having arrived at results that are perfectly clear and satisfactory to myself, when I try to express them I feel that I must begin by putting myself upon quite another intellectual place. I have to translate my thoughts into a language that does not run very evenly with them." This tutorial presents tips, techniques, and guidelines for communicating your designs to others. To be an effective commuicator, you need to know what belongs together and what deserves special emphasis. By choosing what to emphasize, understanding what's fundamental, and using progressive realization techniques, you can unfold a design in successively interesting parts. In this tutorial we'll present options for drawing and explaining your design using informal as well as formal notation. We'll demonstrate some fun ways to get people to simulate object interactions by tossing koosh balls, and we'll have time to plot out your own design's storyline.

Objectives

At the completion of this tutorial attendees should be able to: o Plot a design story o Use techniques to increase emphasis o Order a story's topics from most to least fundamental o Choose an ordering to tell a story based on the audience and context o Determine an appropriate storytelling strategy and format

Tutorial History

This tutorial has been presented at OOPSLA 2007, several software development conferences (SD Best Practices 2007, Architecture and Design World 2007), JAOO 2007 as well as a one day hands on course.

Audience:Practitioners, Educators

Format:Attendees will learn by doing. There will be enough time to explore concepts and techniques and develop a basic plan of action for presenting a story of their choosing. The tutorial is roughly 50% lecture and 50 % exercises followed by review, sharing and reflection.

Classification:Practice

Presenters

Rebecca Wirfs-Brock
Rebecca Wirfs-Brock, president of Wirfs-Brock Associates and IEEE Software's Design Columnist, is a well-known and respected object practitioner. She invented the way of thinking about objects known as Responsibility-Driven Design and is the lead author of Object Design: Roles, Responsibilities, and Collaborations (2003) and the classic Designing Object-Oriented Software (1990). Through her writing, teaching, consulting, and speaking she popularizes the use of informal thinking and communication tools and techniques for designers, architects, and analysts.

The Data Distribution Service for Real-Time Systems (Tutorial 14)

Abstract

The Data Distribution Service for Real-Time Systems (DDS) is a relatively new standard, adopted by the Object Management Group in 2004. DDS has experienced an extremely swift adoption due to (1) its ability to address challenging requirements of real-time and high throughput data distribution in business- and mission-critical systems, such as financial services, air-traffic management and control, and next-generation military land and naval combat systems, and (2) its support for complex QoS along with data centric features typical of Complex Event Processing platforms, such as, relational information modeling, continuous queries, topic projection, and windows. This tutorial will provide an in depth overview of the DDS, explaining its unique data-centric approach, as well as its extremely rich support for QoS controlling every aspect of data distribution, timeliness, and availability. The tutorial will conclude presenting some of the most important DDS Design Patterns, and providing an outlook of the upcoming extensions to the standard, and research challenges.

Objectives

Provide attendees with an understanding of the Data-Centric conceptual model for Publish/Subscribe, and and in depth overview of the Data Distribution Service.

Tutorial History

I've been presenting tutorial in several context, ranging from Corporate Universities, such as THALES University, FINMECCANICA MindShare, in several Academic context, such as Politecnico di Milano, University of Naples, UCR, University of Rome, and in a few conferences and meeting such as DOA, OMG, DEBS08 (upcoming), etc.

Audience:Researchers, Practitioners, Managers, Educators

Format:3hr Presentation with slides + 15m Interactive Demo.

Classification:Educational

Presenters

Angelo Corsaro
Dr. Angelo Corsaro is currently affiliated with PrismTech France where he leads OpenSplice DDS product, addressing technology positioning, planning, evolution, and evangelism, as well as extending the technology adoption to new application domains and verticals. He is also responsible for strategic standardization at the Object Management Group (OMG), where is co-chair of the Data Distribution Service (DDS) Special Interest Group, and of the Real-Time Embedded and Specialized Services Task Force. Angelo received a Ph.D. and a M.S. in Computer Science from the Washington University in St. Louis, and a Laurea Magna cum Laude in Computer Engineering from the University of Catania, Italy.

Exploring IBM SOA Technology & Practice (Tutorial 15)

Abstract

Service-oriented architecture (SOA) is a major technology trend focused on making corporate information technology (IT) an enabler of (not an impediment to) business flexibility and innovation. While SOA is not the unique province of any single vendor, IBM has taken a leadership position in the industry and is actively helping organizations in many industries be successful with SOA. In this talk, Bobby Woolf will review and discuss a number of techniques IBM employs with its customers to help them successfully adopt SOA. While these techniques come from IBM, they are generally applicable to any enterprise using SOA and can be employed with SOA products from any vendor. Topics will include getting started with SOA, SOA reference architectures, service development lifecycle, and SOA governance. This talk is based on Bobby's book, Exploring IBM SOA Technology & Practice.

Objectives

This tutorial will educate attendees about techniques and approaches, based on real world customer practice, for using SOA to help increase the efficiency of business enterprises. Non-IBM customers should also find the techniques helpful.

Tutorial History

Will be presented at ROOTS 2008, April 28-30. Materials have been vetted at numerous IBM conferences.

Audience:Practitioners, Managers

Format:Lecture (PowerPoint)

Classification:Several Areas

Presenters

Bobby Woolf
Bobby Woolf is a member of IBM Software Services for WebSphere, consultants who help customers achieve success with WebSphere products. He is author of the new book Exploring IBM SOA Technology & Practice, and a co-author of Enterprise Integration Patterns and The Design Patterns Smalltalk Companion.

Security - Philosophy, Patterns and Practices (Tutorial 16)

Abstract

Every year, OOPSLA attendees find more than one tutorial on security related issues. So what is different about this tutorial? It builds on core security philosophies and patterns, but more importantly it introduces the participants to many successful security architecture. Additionally this tutorial looks into the future of security engineering and discusses new ways of solving problems. The tutorial will cover three issues. 1. Philosophy. The core philosophies of security architecture. 2. Patterns. Comprehensive view of security pattern catalog and pattern classification. 3. Practices. Explanation of secure software architecture to understand the tradeoffs between different non-functional requirements. Concentration on buffer overflow attacks and the family of injection attacks, and methods to deal with them.

Objectives

This tutorial delivers new ideas to software architects, managers, and researchers. Software architects will learn about the security problems and solutions and will be able to incorporate these solutions in their own design. They will learn fundamental security principles and new security practices. Managers will be introduced to security concepts in this tutorial. They will learn the jargons and will be able to use these jargons in their communication with software architects and designers. Educators and researchers will learn about the research issues on security pattern classification, and new approaches to security engineering.

Tutorial History

Title. Security Patterns and Secure Software Architecture Presenter. Munawar Hafiz Duration. Half day Year. 2007 Where Taught. OOPSLA 2007, Montreal, Quebec, Canada Note. It was among the top five tutorials in terms of attendant count. Title. Security Patterns and Secure Software Architecture Presenter. Munawar Hafiz Duration. Half day Year. 2006 Where Taught. OOPSLA 2006, Portland, Oregon, USA Note. It was among the top ten tutorials in terms of attendant count.

Audience:Researchers, Practitioners, Managers, Educators

Format:The three hour time slot is not equally sliced between the three parts of the tutorial. I shall spend about thirty minutes on the first topic, and split the remaining time between the second and the third topic. The three topics are not covered sequentially. After a brief introduction to basic security concepts, I shall introduce the architecture of three Mail Transfer Agents (MTA): sendmail, qmail and Postfix. The architecture will be described in a top-down manner highlighting the design decisions that contribute to their security (or insecurity). I shall also introduce some related security patterns present in the architecture. This will be followed by an introduction to security pattern classification schemes and a discussion of a subset of access control patterns. Then, I shall start discussing the core philosophies of security. Failing to understand the core philosophies is the root couse of our security woes. I shall describe core security principles such as partitioning of privilege, least privilege principle, content dependent processing, trust partitioning, etc and cite examples showing that violation of these rules is the main cause of security problems. Finally, I shall cover buffer overflow attacks and the family of injection attacks and show how these problems can be solved in new ways. These techniques are part of new methodologies of security engineering that can be used to retrofit security into existing systems.

Classification:Several Areas

Presenters

Munawar Hafiz
Munawar Hafiz is a Ph.D. student at the University of Illinois at Urbana-Champaign. His research interests are software architecture and design, software patterns and security. He aims to change the philosophy of security engineering through his research. Currently, he is working on techniques to retrofit security into existing software.

Advanced Software Architecture (Tutorial 17)

Abstract

In theory, software architecture is the key to sustainable high-quality software systems that meet requirements such as scalability, flexibility and whatelse might be on the project's wish list. In practice, many projects fail to achieve their objectives. Is building quality software systems just a myth? Is it a black art only a few can master? Or, is there a kind of toolbox architects could establish to reduce the risk of failure? It is the goal of the tutorial to provide such a toolbox. It introduces a number of guidelines and practices from real life experience. In the first part it addresses what exactly software architecture is about and what the role of a software architect should be. Then, the tutorial provides practices and guidelines for developing a concrete architecture. In its third part the tutorial also looks on the other side of the coin: how can we evaluate existing software architecture? What are the qualities a high quality software system typically reveals. At the end of the day, attendes will get at least a foundation for their own software architect's toolbox.

Objectives

Clarifying the role of software architecture and the role of software architects Providing a toolbox that consists of practices and guidelines for software architecture design and evaluation.

Tutorial History

This tutorial has also been presented in last year's ooPSLA 2007. The attendee feedback has been very positive. Nonetheless, the feedback lead to a some major improvements

Audience:Practitioners, Educators

Format:Powerpoint slides with real life exmaples

Classification:Several Areas

Presenters

Marwan Abu-Khalil
Marwan Abu-Khalil is a senior software architect at Siemens Corporate Technology in Michael Stal's team. He is a consulting specialist for the industry sector. His main research interests include distributed and concurrent systems. He also gained broad experience working as an architect for airline software at Lufthansa-Systems. Marwan holds a master in mathematics and a master in computer science. He has been a conference speaker on enterprise architectures for Java and .Net.

Michael Stal
Dr. Michael Stal is a Principal Engineer and Team Lead at Siemens AG where his research and consulting activities focus on Software Architecture and Distributed Systems. He is co-author of the book series Pattern-Oriented Software Architecture as well as of several other publications. In addition, he was appointed Microsoft MVP Solution Architect and serves as editor-in-chief of the german JavaSPEKTRUM magazine since 1996. Michael also has been a frequent speaker at various international events.

Economics-Driven Architecting (Tutorial 18)

Abstract

Since software engineering artifacts exist to serve the business goals of an enterprise, optimizing the value of software systems is a central concern of software engineering. However, software engineers are not well equipped with techniques that can assist them in making value-based decisions. Existing techniques in software economics address software engineering life-cycle practices, most of which rely on techniques that culminates in implementation and code-level activities. Equipping software engineers with the ability to reason about software economics will provide them with the vocabulary and rationale needed to articulate the value-driven impact of architectural decisions. This half-day tutorial will provide researchers and practitioners who need to reason about and make software architecture decisions with economics-driven techniques. The tutorial presents techniques for combining utility, quality attribute reasoning, and software architecture decision making to best serve the business context. Format involves lectures, a case study where the techniques presented were applied in a real-world setting, and a hands-on exercise.

Objectives

The Economics-Driven Architecting tutorial is a half-day, hands-on tutorial providing coverage of how to bring economic and value-based considerations into software architecting. The objectives of the tutorial are to: o familiarize participants with essential considerations in economics-informed and value-driven software design and analysis o introduce techniques--real option analysis and the cost-benefit analysis method--for making value-based software architecting decisions o provide participants with a better understanding of the methods through a hands-on exercise The goal that these objectives serve is raising the appreciation and understanding of the participants for applying economics considerations during the software architecting activities of a project. We aim to give them practical and readily applicable tools that they can experiment with in their own domain after completing this tutorial.

Tutorial History

The economics-driven architecting tutorial that is described in this proposal was offered by the presenters in this format and in extended versions several times in both industry and academic settings since 2007. A full-day version of the tutorial was offered at WICSA 2008 in Vancouver, Canada. The full-day version also focused on techniques such as real-options, which in this tutorial we will only briefly present due to scheduling constraints. The WICSA tutorial was very well attended by practitioners especially and received very good feedback. A half-day version of the tutorial was also offered to senior architects at UniSys, Inc. in February and April of 2007 and it was very well received. Also guest lectures based on the material in this tutorial were presented in a graduate course at the Carnegie Mellon University, as well as at the University of Jyvaskyla (Finland), the University of Calgary (Canada), and at Nokia Corporation.

Audience:Researchers, Practitioners, Managers, Educators

Format:The tutorial uses lectures, hands-on exercises, and discussions as teaching methods. Lectures and discussions will be used to intro-duce and motivate the concepts. Discussions will be encouraged to help participants relate the material to their own domain. A key teaching method used in the tutorial is a running exer-cise that will be used to give the participants the opportunity to apply the techniques discussed on a model problem. The hands-on example makes the core of the tutorial for optimal learning out-comes. Sample answer to the exercise will be provided for the participants.

Classification:Several Areas

Presenters

Rick Kazman
Rick Kazman is a Professor at the University of Hawaii and a visiting scientist in the Product Line Systems Program at the SEI. His primary research interests are in software architecture, design and analysis tools, software visualization, and software engineer-ing economics. He also has interests in human computer interac-tion and information retrieval. He is the author of over 100 technical papers and co-author of several books including the books Software Architecture in Practice (2nd edition appeared in 2003) and Evaluating Software Architectures: Methods and Case Studies (2002). Further information about Dr. Kazman can be found at http://www.sei.cmu.edu/staff/rkazman/.

Ipek Ozkaya
Ipek Ozkaya is a senior member of the technical staff in the Prod-uct Line Systems Program at the SEI. Her research interests in-clude developing methods for improving software architecture practices focusing on software economics and requirements man-agement. She received her PhD in computational design from Carnegie Mellon University in 2005. Ipek Ozkaya can be con-tacted at This e-mail address is being protected from spambots. You need JavaScript enabled to view it . Further information about Dr. Ozkaya can be found at http://www.sei.cmu.edu/staff/ozkaya/.

Making your Methodology Crystal Clear and More (Tutorial 20)

Abstract

Crystal is a family of agile and human-powered methodologies for various sizes of projects. The family is described through its genetic code, so that you can create your own family member. The genetic code includes understanding software development as a cooperative game; a set of properties to strive for on your project; a description of process as nested cycles of different lengths; a starter kit of techniques and project management strategies; a sampling of work products to copy or adjust to your needs; and a couple of example methodologies to crib from. Crystal Clear is the smallest, lightest and best-developed family member, intended for colocated teams of 3 to 8 people. It has been evaluated for ISO9000 compliance ability. This tutorial is for people curious about how methodologies can come in a "family pack"; people wanting to see actual work products created by project teams rather than templates of deliverables; people wanting exposure to some of the less-known agile techniques, and people interested in learning the seven properties of successful software projects.

Objectives

To expose the insides of the Crystal family of methodologies, show how to borrow from the Crystal Clear description, and discuss how to twist it to other needs.

Tutorial History

OOPSLA 2007. A predecessor to this tutorial has been shown numerous times, including SD West 2006, based on people's increasing interest in Crystal. This version was updated to fit the inquisitive attendee. It will highlight the examples of work products rather than the design principles (since the principles are in the "Techniques and Principles for Rolling Your own Methodology" tutorial). A tutorial just on the work products was given at the Better Software conference in 2005.

Audience:Practitioners

Format:Lecture plus discussion

Classification:Practice

Presenters

Alistair Cockburn
Dr. Cockburn helped write the Manifesto for Agile Software Development and the Declaration of Interdependence. Three of his books, "Agile Software Development: The Cooperative Game," "Crystal Clear: A Human-Powered Methodology for Small Teams," and "Writing Effective Use Cases" have won Jolt awards. He is widely recognized as the foremost expert on use cases, as the creator of the Crystal family of methodologies; and for the management strategies he has collected from projects around the world. Find his materials online at http://alistair.cockburn.us.

Succeeding with Reference Architectures (Tutorial 21)

Abstract

Many companies have attempted to define Reference Architectures, but few have succeeded to gain benefits from these efforts. This unique and pragmatic tutorial provides the information needed to succeed with Reference Architectures and ultimately with your Enterprise Architecture efforts, based on lesson learned from successes and failures over the last 10 years working with enterprises of all sizes and all industries.

This tutorial addresses:

o Concepts and context behind Reference Architectures. Why are Reference Architectures important.

An overview of different kinds of Reference Architectures

An overview of Reference Architecture definition approaches

Usages of Reference Architecture: How and when companies are using these reference architectures, to achieve their IT and enterprise objectives.

A discussion of best practices, success criteria, and typical pitfalls in Reference Architectures.

Using Reference Architectures as tool to Manage IT as a Business, for the Business.

Defining cross-project, cross-application, and application-specific Reference Architectures

Functional, technical, interoperability, and business architectures The tutorial illustrates several examples of Reference Architectures.

Objectives

Provide pragmatic experience-based guidance on how to succeed with the definition and use of Reference Architectures and ultimately how to benefit from an enterprise architecture effort

Tutorial History

This tutorial is based on material used during our consulting engagements and is a significant evolution and improvement of tutorial previously given with success at conferences and during customer-specific courses

Audience:Researchers, Practitioners, Managers, Educators

Format:Using a speaker-led tutorial with frequent real-world examples, the presenter will challenge participants into contributing their experience

Classification:Practice

Presenters

Peter Herzum
Peter has always been at the forefront of pragmatic approaches to software and IT. He pioneered object-oriented approaches in-the-large in the '80s; component-based approaches, software factories, and agility in-the-large in the '90s; SOA and enterprise architectures since 1999, and "IT as a business" best practices since 2000. The creator of COSM, the third-generation IT approach for individual projects and enterprise-level IT, he is the author of many ground-breaking publications, including the best-selling book "Business Component Factory", translated in several languages and adopted by architectural curriculums around the world. Peter is a frequent keynote speaker at IT conferences world-wide.

The F# Programming Language (Tutorial 22)

Abstract

F# is a new programming language for the .NET platform, which has recently moved from incubation in Microsoft Research to productization by Microsoft Developer Division. F# is hybrid functional and OO language which combines the succinctness, expressivity, and compositionality of typed functional programming with the object model, runtime support, libraries, interoperability and tools of .NET. This tutorial will provide a thorough introduction to the F# language and tools, a look at some areas where F# is being used in industry, and deep dives into some of F#'s innovative language features.

Objectives

Particpants will learn the F# language.

Tutorial History

New tutorial. The content is based on (and extends) material presented at TechEd and similar conferences.

Audience:Researchers, Practitioners, Educators

Format:This tutorial will be 75% lecture based and 25% small group programming exercises.

Classification:Several Areas

Presenters

Luke Hoban
Luke Hoban is the Program Manager for F#. Before moving to the F# team, Luke was the Program Manager for the C# Compiler, working on C#3.0 and LINQ. Prior to that, Luke worked with the C# IDE group, and was responsible for the Visual Studio Express line of products which were launched in VS2005.

Don Syme
Don Syme is a researcher at Microsoft Research in Cambridge. His first major project at Microsoft was .NET Generics, which he proposed to the Microsoft Product teams in 1999 and saw through to productization in C#, VB and C++ in Visual Studio 2005. Since then he has been researcher and design lead on F#.

Refactoring Legacy C++ Code to Testable C++ (Tutorial 23)

Abstract

You are finally taming that legacy C++ code with tests, but it is stubbornly resisting. This tutorial will present some hard-to-test examples of C++ code and how it can be refactored into testable code. Students who need to maintain legacy C++ code, and want to test and refactor it, will learn techniques to help them do this work safely and with minimal changes in the performance of their software. We will cover several legacy examples in which code is initially not accessible by tests, but subsequently made more testable with the techniques presented.

Objectives

To learn techniques of making legacy C++ code easier to unit test. To apply those techniques in a real-world C++ setting. Emphasis will be on the refactorings, not on the testing.

Tutorial History

The slides for this tutorial (although not the live refactorings) were presented at SD West 2008, on March 6, 2008.

Audience:Practitioners

Format:50% slides and lecture, and 50% exercises using gcc and/or Eclipse CDT. The attendees will practice testing and refactorings on source code available from the presenters.

Classification:Practice

Presenters

Keith Ray
Keith Ray has been a professional programmer since the mid-1980's shipping shrink-wrapped and other software on Macintosh, Windows and Unix platforms using C++, Objective-C and Java. In recent years, he has concentrated on mastering Design Patterns, Extreme Programming and Test-Driven Development, as well as agile team-work practices. Keith enjoys working side-by-side with individuals to improve their refactoring and test-driven development skills. He is passionate about improving code quality and software ease-of-use, while pragmatic about delivering products on-time. Keith has published articles about XP and Refactoring; blogs on Agile and other topics, and lives near Silicon Valley in the San Francisco Bay Area.

Joshua Kerievsky
Joshua Kerievsky is founder of Industrial Logic, an early pioneer and expert in Extreme Programming (XP), author of the best-selling, Jolt Cola Award-winning book Refactoring to Patterns, thought leader behind Industrial XP, a state-of-the-art synthesis of XP and Agile Project Management and an innovator of Agile eLearning, which helps organizations "Scale Agility Faster." Joshua has over 20 years of experience in software development and loves coaching agile project communities, helping executives understand and manage technical debt, leading excellent workshops, and building software products (because it enables him to "walk the agile talk" as an entrepreneur, manager, customer and programmer).

Spring and OSGi Combined with Spring Dynamic Modules (Tutorial 24)

Abstract

OSGi provides a firm foundation for application development, bringing with it strong modularity, versioning support, and dynamic configuration. The open source Spring Dynamic Modules (Spring-DM) project was founded to enable enterprise application developers to exploit these platform benefits by combining the familiar Spring programming and configuration model with the sophistication of the OSGi Service Platform. In this tutorial we will go through a number of examples together explaining the concepts behind Spring-DM and showing how Spring-DM can be used to implement various kinds of enterprise applications. Attendees will see running examples for using Spring-DM with the dynamic nature of OSGi and how service implementations can be replaced on the fly without the direct use of the OSGi APIs. We conclude with some experiences from real-world projects and a short discussion of what is currently missing in Spring-DM. Examples are implemented during the tutorial using the latest versions of the Equinox OSGi runtime and the Spring Dynamic Modules project.

Objectives

Attendees of this tutorial learn how the Spring Framework can be used together with OSGi to build modularized enterprise applications. The tutorial provides examples and concepts so that attendees are able to start right away using these techniques after visiting the tutorial.

Tutorial History

Previous versions of the tutorial were presented at EclipseCon 2007 and 2008 (among top 3 ranked tutorials). The contents of the tutorial will be updated to keep up with the latest versions of the Spring Dynamic Modules project.

Audience:Practitioners

Format:The tutorial will start with a short slide-based introduction of the core concepts and starting points in about 30 minutes or less. After that, the tutorial will be a combination of hands-on exercises, where participants are working on their laptops, and demos and examples that are shown and developed by the presenter live in front of the audience.

Classification:Practice

Presenters

Martin Lippert
Martin Lippert is a consultant at akquinet it-agile GmbH, a company focused on agile software development. He received a master degree in Computer Science from the University of Hamburg and worked as intern as part of the AspectJ team at Xerox PARC back in '99. While he is helping teams to adopt agile methods he also authored several articles on client- and server-side development with Eclipse/OSGi technology and investigated its combination with AOP. He is involved as a committer in the Equinox incubator project and speaker and tutorial presenter at conferences including OOPSLA, EclipseCon, OSGi DevCon, Spring Experience, and more.

Product-line Modeling and Automation with Eclipse (Tutorial 25)

Abstract

A core activity in developing a Software Product-Line (SPL) is the documentation of product variability. Product variability dictates the rules governing how an application can be retargeted to different requirement sets. Typically, product variability is captured in models, such as feature models. Once models are built that document SPL variability, tool support can be developed to help SPL engineers configure individual SPL variants. Often, complex automation may be needed to help choose good or optimal settings for the SPL's points of variability. Developing these modeling tools and automation mechanisms is challenging. This tutorial introduces Eclipse-based modeling technologies that can be used to help reduce the cost of building model-based SPL configuration tools. Furthermore, the tutorial covers different Eclipse frameworks that can be used to build constraint-based automation mechanisms into SPL modeling tools for Eclipse. Finally, the tutorial provides an introduction on how these automation mechanisms can be used to help derive optimal variants and product/application configurations for a requirement set.

Objectives

First, we will explain the motivation for Product Line Modeling and Configuration Automation and how it relates to Product Variant Selection and Product or Application configuration. People will become familiar with Eclipse-based tools for Product Line Modeling and Configuration Automation. Moreover, we will show how to use the Generic Eclipse Modeling System (GEMS) -to build feature models, integrate different feature model instances, and debug feature configurations -to leverage its constraint-based automation support to perform optimal product variant selection and visual modeling guidance. -to perform runtime automated model-based configuration of applications at application launch -to use the Java Spring framework to create applications that can perform feature model-based failure recovery

Tutorial History

A version of this tutorial, geared towards general domain-specific modeling and automation, was presented at OOP 2008. The after class evaluations rated the tutorial 1.2 out of 5 (1 being the best) for the technical skills of the speakers, 1.5 out of 5 for skill in answering audience questions, and an overall rating of 1.9 out of 5 for the course. Furthermore, 95% of respondents said that the course was "exactly what I needed" and 75% of respondents said that they would recommend the course to a friend. Individually, Jules White and Egon Wuchner have presented various portions and versions of this tutorial to a mix of industrial and academic audiences, such as Siemens AG, IBM, Borland, Lockheed Martin, Waterloo University, University of Alabama at Birmingham, and Vanderbilt University.

Audience:Researchers, Practitioners, Managers

Format:Our tutorial materials includes slides, step-by-step code examples, the complete source code for all examples covered in the tutorial, and guides to further examples that can be pursued by participants after the tutorial is over. We will provide USB keys with fully configured Eclipse instances for attendees who would like to follow along with the live coding examples.

Classification:Several Areas

Presenters

Jules White
Jules White is a researcher in the Distributed Object Computing (DOC) Group at Vanderbilt University in Nashville, TN, USA. He is the project leader for the Eclipse Modeling Project's Generic Eclipse Modeling System. Jules' research focuses on constraint-based automation and optimization techniques for feature modeling and domain-specific modeling. Previously, Jules worked on large-scale optimization systems for IBM's Boston Innovation Center. Jules has given tutorials at conferences such as OOP and Models. Furthermore, Jules has published and presented papers at conferences, such as SPLC, ICAC, EDOC, AOSD, Models, and TOOLS. He has given technical presentations to industrial partners, such as Siemens, IBM, Lockheed Martin, Raytheon, PrismTech, and others.

Egon Wuchner
Egon Wuchner is senior engineer at Corporate Technology, Siemens AG in Munich. He is a consultant within Siemens in the fields of software architecture and distributed systems. Currently, he is involved in large-scale autonomic computing projects that use model-driven development, software product lines, and constraint solver-based automation. Egon has given tutorials at OOP and Siemens-internal conferences. He has published papers at conferences such as AOSD and SPLC.

Test-Driven Development - Hands-on! (Tutorial 26)

Abstract

Curious about Test-Driven Development? Heard a lot about it, but never had a chance to really try it? This tutorial will give you hands-on experience with Test-Driven Development in Java and/or C#. Bring your laptop with either a new version of Eclipse or Visual Studio (2003 or 2005) installed and you'll get a real Test-Driven kick-start. We will provide you with the additional tools/frameworks you'll need. You will get a feeling for what it's like to make changes to a system that has a lot of tests (no more "this looks ugly, but I don't have the guts to change it"). You'll also experience how writing test code before writing the production code changes the way you think about and design your production code. The tutorial will introduce you to Test-Driven Development, refactoring, unit-testing frameworks, and mock frameworks. You'll have the opportunity to try these for yourself in C# or Java, with the presenters helping out and answering your questions. (Note - bring a laptop with a recent version of Eclipse or Visual Studio or be prepared to pair program with someone else)

Objectives

We want to introduce Test-Driven Development to developers and get them started immediately.

Tutorial History

This tutorial has been given at OOPSLA 2006 and OOPSLA 2007 and at some European conferences as well. The feedback is always taken into consideration and the feedback improved significantly between the first and second time it was given at OOPSLA. We will continue to improve the material and we will also provide solutions to the exercise, step by step, which some attendees asked for in 2007. One recurring thing to note though is that people seem to miss that they need to bring a computer. Maybe OOPSLA should send them a reminding email, or explicitly give them that information when registering. (Some people just don't seem to read the abstract too closely)

Audience:Practitioners

Format:70% excercise, 30% lecture.

Classification:Practice

Presenters

Niclas Nilsson
Niclas is a software developer, consultant, educator, and writer, with a deep passion for the software development craft. He started working as a developer in 1992 and, drawing from experience, he knows that some choices makes significant difference in software development, like languages, tools and processes. This is the reason behind his affection for dynamic languages, test-driven development, code generation, and agile processes. He has been test-driven for over five years and has so far used test-driven development in Java, C++ and Ruby. Blog at http://niclasnilsson.se

Andreas Brink
Andreas Brink is a programming architect, working as a consultant at factor10. Equally comfortable with Java, .NET, or dynamic languages, his focus is on the general aspects of software development: design, architecture, and methodology. As a trainer and coach, he provides individuals and teams with simple and practical tools to boost software productivity and quality. One of his specialties is test automation, both as a design tool, and for taking control of legacy code. Blogs at http://blog.andreasbrink.se/

Writing Effective Use Cases for Projects both Agile and Otherwise (Tutorial 27)

Abstract

This tutorial shows how to write use cases that are short, effective and elegant, based on the award-winning book recognized as the reference standard on use cases. A good use case has an main success scenario that is three to nine steps long, plus scenario extensions that cover situations that may show up along the way. What makes a good use case special is the understanding the writer has of the scope of action in every step, the use of goal-oriented verbs in each sentence, alertness to the level of the goal in each step, clear movement of information and responsibility across actors in each step, and a story line that ties these steps to a goal of the primary user. When these notions are applied, even complex use cases become short and simple enough for lay people to understand and critique. This tutorial covers the critical but often unstated ground rules about scope, goal level, and actors. It then covers how to collect them and simplify the use cases. Time will be left for discussion about interesting problems the attendees have, and the application of use cases to agile and incremental development projects.

Objectives

To simplify the exposition of effective use cases so that people can actually write them, to expose the critical concepts that allow effective use cases to be written, and to answer interesting questions the attendees might have.

Tutorial History

OOPSLA 2007. This tutorial is a brief version of the highly acclaimed 2-day course that matches the award-winning book. Before 2007 it was presented at conferences before, but those were lectures only. This version was being updated to simplify the presentation to allow more time for audience interaction. The presenter is recognized as one of the world experts on this topic.

Audience:Practitioners

Format:Lecture plus exercise

Classification:Practice

Presenters

Alistair Cockburn
Dr. Cockburn helped write the Manifesto for Agile Software Development and the Declaration of Interdependence. Three of his books, "Agile Software Development: The Cooperative Game," "Crystal Clear: A Human-Powered Methodology for Small Teams," and "Writing Effective Use Cases" have won Jolt awards. He is widely recognized as the foremost expert on use cases, as the creator of the Crystal family of methodologies; and for the management strategies he has collected from projects around the world. Find his materials online at http://alistair.cockburn.us.

Real-time Programming on the Java Platform (Tutorial 28)

Abstract

Real-time programming and Java are not normally synonymous. Real-time is often associated with specialized application domains such as avionics, process control and communication systems. Since the advent of the Real-time Specification for Java in 2000, the Java platform has extended its reach into these specialized domains. Meanwhile mainstream Java application domains, such as banking and finance, have been pushing the limits on traditional Java platform technology. What is being sought is often not raw performance, but predictability of response times - and this is what Real-time Java was designed to provide. One of the catalysts in the recent surge in interest in mainstream real-time Java programming is the development of Real-time Garbage Collection. RTGC provides a bridge between traditional Java development and the more complex memory management model provided within the RTSJ. This tutorial explores the concepts and API's behind the RTSJ and provides a primer on real-time garbage collection offerings.

Objectives

To familiarise the audience with the facilities provided by the RTSJ and by RTGC such that they can evaluate the potential use of either within their chosen application domain.

Tutorial History

This tutorial was first presented at OOPSLA 2007, where it was well received. It has been proposed for the JAOO Australia conference in May/June 2008.

Audience:Practitioners

Format:Lecture

Classification:Practice

Presenters

David Holmes
Dr David Holmes is a Senior Java Technologist at Sun Microsystems. His work with Java technology focuses on real-time programming, concurrency and synchronization support in the virtual machine. David is a member of the Technical Interpretation Committe for JSR-001 - The Real-Time Specification for Java 1.0 (RTSJ). He is also a member of the JCP Expert Group for JSR-282, which is defining RTSJ 1.1. David was also a member of the JCP Expert Group for JSR-166 "Concurrency Utilities". He is a contributing author to "Java Concurrency in Practice", by Brian Goetz et al, and a co-author of "The Java Programming Language" - Third and Fourth Editions, with Ken Arnold and James Gosling. David has been a regular presenter at conferences like OOPSLA and JavaOne for a number of years. He completed his Ph.D. at Macquarie University, Sydney, in 1999, in the area of synchronization within object-oriented systems.

Tony Printezis
Dr Tony Printezis is a Staff Engineer at Sun Microsystems, located in Burlington, MA. He has been contributing to the Java HotSpot Virtual Machine, as well as the Java Real-Time System, since the beginning of 2006. Before that, he spent over 3 years at SunLabs. He spends most of his time working on dynamic memory management for the Java platform, concentrating on performance, scalability, responsiveness, parallelism, and visualization of garbage collectors. He joined Sun Microsystems in 2002 after a 2.5-year research collaboration, while he was a member of the faculty of the Department of Computing Science of the University of Glasgow. He obtained a PhD in 2000 and a BSc(Hons) in 1995, both from the University of Glasgow in Scotland.

Skills for the Agile Designer (Tutorial 29)

Abstract

What makes an agile designer effective? Agile designers need to quickly see the essence of a problem, shape reasonable solutions, and communicate complex ideas. When things don't exactly go according to plan, they must react, readjust their thinking, and try again. This tutorial introduces several techniques and vocabulary for articulating the nature of design problems and their solutions: Problem frames identify the 'typical structure' of software tasks. Designer stories set the stage for collaborative design. Role stereotypes are useful for assigning or assessing object behaviors. Control styles can help characterize and communicate control center designs. Trust regions can aid in spotting places where 'defensive' programming is needed.

Seasoned designers strike a balance. They know the difference between core and revealing design tasks and plan accordingly. When unanticipated difficulties crop, they adapt their work rhythms. Finally, we conclude by introducing different forms of criticism and how to handle them on the spot so you can hold your own and even learn something instead of having a heated discussion.

Objectives

At the end of this tutorial attendees should be able to: Identify problem frames (types) and use them to ask probing questions of their customers Write and share designer stories to kick off an iteration Use a common vocabulary for characterizing various aspects of a design Sort through designs tasks and identify their project impact Recognize when a "wicked" problem crops up and how it affects project flow Effectively discuss issues and come to meaningful agreements

Tutorial History

This tutorial has been presented in various forms since 2003 at various agile conferences. Most recently it has been presented at Agile 2007 and OOPSLA 2007. It had its roots in an invited talk I gave in 2003 to the Object Technology Users' Group in Minnesota's evening lecture series.

Audience:Practitioners, Educators

Format:This tutorial combines short presentations introducing new concepts and techniques with short, to-the-point exercises. In addition to course slides, attendees receive notes describing each technique, concept, or practice.

Classification:Practice

Presenters

Rebecca Wirfs-Brock
Rebecca Wirfs-Brock invented the way of thinking about objects known as Responsibility-Driven Design. She is lead author of the classic Designing Object-Oriented Software (1990 still in print!), and Object Design: Roles, Responsibilities and Collaborations (2003). She is the design columnist for IEEE Software and on the board of directors of the Agile Alliance. Through her writing, teaching and speaking she popularizes the use of informal techniques and thinking tools for designers, programmers, and analysts. Among her widely-used inventions are object role stereotypes and the conversational form of use cases.

Building Domain-Specific Languages for the Web (Tutorial 30)

Abstract

Implementing web applications in an object-oriented language such as Java using state-of-the-art frameworks produces robust software, but involves a lot of boilerplate code. Domain-specific languages (DSLs) increase the productivity of software engineers by replacing such low-level boilerplate code by high-level models from which code can be generated automatically. This tutorial presents principles and techniques for the design and implementation of DSLs illustrated using WebDSL, a domain-specific language for the high-level modeling of the data model, user interface, access control policy, and workflow procedures of web applications. The tutorial explores the process of designing a DSL from the derivation of domain-specific abstractions from patterns in code to the automatic generation of code from models. In particular, we will study the paradigm of code generation by model transformation. Rather than using a textual template engine producing unstructured text, a structured representation is generated to which further transformations can be applied. This enables the extension of the target language to facilitate code generation, for instance by the assembly of partial code fragments and aspect weaving. Furthermore, it supports the stacking of higher levels of abstraction. These techniques are explained using the high-level DSLs for language engineering from the Stratego/XT tool set. The syntax definition formalism SDF supports modular definition of (composite) languages. The Stratego transformation language unifies model transformation and code generation. The use of concrete object syntax allows structured transformation patterns to be phrased in the syntax of the source or target language. The tutorial compares the approach to other language engineering paradigms.

Objectives

The attendees will learn, by means of an example, how to design a domain-specific language for an existing application domain. - looking for patterns in existing code - designing abstractions to capture patterns - transformation techniques for implementing these abstractions - building abstractions on top of abstractions The domain of web engineering used as illustration in the tutorial is useful because it is both relevant in current software development practice, and a domain that is familiar to attendees, at least from the usage side.

Tutorial History

The tutorial was originally developed for the GTTSE 2007 summerschool on Generative and Transformational Techniques in Software Engineering, which was held in July 2007. The material has been used in a number of other lectures since. The tutorial will be adapted to incorporate new developments in WebDSL and insights gained from previous presentations. A reduced version of the tutorial is scheduled for presentation at Code Generation 2008.

Audience:Researchers, Practitioners

Format:Lecture

Classification:Several Areas

Presenters

Eelco Visser
Eelco Visser is Associate Professor at Delft University of Technology. He has a longstanding interest in giving programmers the means to create new programming abstractions by means of transformations. A central theme in his research is implementation techniques for program transformation systems. Research contributions in this area include scannerless generalised-LR parsing, generic traversal strategies, dynamic rewrite rules, and a number of tools built on these and other techniques. He is the principal designer and implementor of the syntax definition formalism SDF2, the Stratego/XT language and toolset for program transformation, and the WebDSL domain-specific language for web application development.

Pattern-Oriented Software Architecture: A Pattern Language for Distributed Computing (Tutorial 31)

Abstract

Developing software for distributed computing applications that effectively utilizes concurrency over high-speed, low-speed, and mobile networks is hard; developing high quality reusable distributed applications is even harder. Many patterns in the software literature focus on distributed computing. Until recently, however, there has been no holistic view of distributed computing that emphasizes how groups of patterns complete and complement each other. Building complex distributed systems has therefore been a craft that many have tried, but few have mastered. To address this issue, this tutorial describes a pattern language that links hundreds of patterns relevant for distributed computing, including: (1) Object interaction, (2) Interface and component partitioning, (3) Application control, (4) Resource management, (5) Concurrency and synchronization. This pattern language has been used successfully by the speaker on production distributed applications and middleware at hundreds of commercial companies for telecommunication systems, network management for personal communication systems, electronic medical imaging systems, real-time avionics and aerospace systems, and automated stock trading. The material presented in this tutorial appears in the book "Pattern-Oriented Software Architecture: A Pattern Language for Distributed Computing", Wiley & Sons, 2007 by Frank Buschmann, Kevlin Henney, and Douglas Schmidt.

Objectives

Upon completing this tutorial, attendees will be able to: . Recognize the inherent and accidental complexities involved with developing distributed applications. . Understand precisely how object-oriented techniques and tools can and cannot help to alleviate this complexity. . Apply key object-oriented design techniques (such as pattern languages, frameworks, and components) to develop reusable distributed application artifacts. . Utilize OO language and middleware feature to create efficient, robust, reusable, and extensible distributed applications. . Understand advanced OS capabilities and use them effectively to develop extensible, robust, reusable, and efficient concurrent distributed ap