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 applications. . Know where to find additional sources of information on how to successfully apply object-oriented techniques to distributed applications.

Tutorial History

Variants of this tutorial have been presented at OOPSLA for the past 14 years. The material has changed over time (e.g., as new POSA books were published), but the tutorial has always been well received. I plan to update my proposed tutorial to further incorporate material from the recent POSA4 and POSA5 books.

Audience:Researchers, Practitioners, Educators

Format:Lecture and discussion

Classification:Several Areas

Presenters

Douglas C. Schmidt
Douglas Schmidt is a Professor of Computer Science and Associate Chair of the Computer Science and Engineering program at Vanderbilt University. He has published 9 books and over 400 technical papers that cover a range of research topics, including patterns, optimization techniques, and empirical analyses of software frameworks and domain-specific modeling environments that facilitate the development of distributed compting middleware and applications. In addition to his academic research, Dr. Schmidt has over fifteen years of experience leading the development of ACE, TAO, CIAO, and CoSMIC, which are widely used, open-source middleware frameworks and model-driven tools.

SOA Architecture and Design Strategies (Tutorial 32)

Abstract

SOA can be defined as an architectural style promoting the concept of business-aligned enterprise services as the fundamental unit of designing, building and composing enterprise business solutions. Multiple patterns, definitions, implementations and deployment of the SOA solutions comprise this style. In other words, a service-oriented architecture (SOA) describes how to build systems that are composed of services. But, more importantly, SOA is concerned with the independent construction of services that can be combined into meaningful, higher-level business processes within the context of the enterprise. Anybody can create a service that is not the challenge of SOA. The real value of SOA comes when reusable services are composed together to create agile, flexible, business processes. Yet another promise of SOA is business/IT alignment. This promise can be achieved only if the services are aligned with the business model of the enterprise. Consequently, an enterprise business model is a requirement for a successful SOA implementation. This approach to the definition of enterprise business services allows for better alignment of business, organizational and application architectures. This tutorial presents a true SOA design strategies that supports the SOA architectural style and describes a holistic approach to design, creation, utilization and execution of services - the complete SOA lifecycle. These strategies cover three major areas: service design, implementation and execution.

Objectives

An objective of the tutorial is to explain service-oriented architecture, its relationships to Enterprise Architecture, what makes this architectural style different from other styles, and practical approaches to SOA design. Attendees will learn how to approach SOA starting from business modeling, service-oriented decomposition, and the definition of enterprise semantic data modeling. The tutorial will also explain how to leverage the results of modeling and existing enterprise applications for implementing services. We will also cover approaches to service composition, security, and SOA runtime services and the role and function of SOA Governance.

Tutorial History

It is a new tutorial, based on the numerous presentations by the authors and their upcoming book "Applied SOA: Architecture and Design Strategies"

Audience:Practitioners, Managers, Educators

Format:The tutorial will be presented in a form of slide show with multiple real-life examples, illuminating major points.

Classification:Practice

Presenters

Boris Lublinsky
Boris Lublinsky is a Lead Architect at Navteq. Dr. Lublinsky has over 25 years of experience in IT industry with over 10 years in Software Architecture and over 5 years in SOA. Boris has over 50 publications on SOA, Web Services, J2EE, XML and enterprise architecture and is a frequent presenter on SOA and Architecture topics.

Mike Rosen
Mike Rosen is Chief Scientist at Wilton Consulting Group. Mr. Rosen is also Director of Architecture at the Cutter Consortium, and Editorial Director of SOA Institute. Mr. Rosen specializes in Enterprise Architecture, Service Oriented Architecture (SOA), and model driven systems. He has years of experience consulting in the architecture and design of applications for global corporations in Finance, Insurance and Telecom. Mike draws on his 20+ years of product development experience in distributed technologies including Web Services, J2EE, XML, CORBA, COM, DCE, transaction processing, and messaging.

Introducing New Ideas into Your Organization (Tutorial 33)

Abstract

Are you struggling to help your team or organization become more innovative? Do you have great ideas but can't seem to get them off the ground? Then this tutorial is for you. Many OOPSLA attendees uncover new ideas they want to take back, but then struggle to make something happen. You will learn the secrets of successful change agents documented in the presenters' book: Fearless Change: Patterns for Introducing New Ideas. Bring your frustrations! This tutorial allows you to see some of these patterns in action and then have an opportunity to apply them to your own problems.

Objectives

Participants will better understand a process of introducing new ideas into organizations. They will improve their understanding of innovation by discussing and applying patterns that document the lessons learned by successful change agents.

Tutorial History

This tutorial has been given by one or both of us many times, both in academia and industry. We are continually improving this tutorial, since we do retrospectives after each event. Presentations include seminars, workshops, and conferences such OOPSLA'00, OOPSLA'01, and OT'01, JAOO'02. In addition, we gave an invited talk on this topic at the XP2004 conference in June 2004 and it has been a part of every Agile 200X conference since.

Audience:Researchers, Practitioners, Managers, Educators

Format:The tutorial is a combination of lecture, exercise, and group question and answer. It is a highly interactive session. 00:00 Introductions (leaders and participants). Description of the session and the materials. 00.15 Lecture and discussion. Introduction to the patterns, experiences, and lessons learned. 01.30 Break 01.45 Problem clinic. Participants are invited to share real-world dilemmas. Participants form small teams and use the patterns to create a strategy for solving as many of these dilemmas as possible. 02:30 Teams present their solutions; tutorial leaders offer suggestions. 03:00 De-brief. Summary of the session. 03:30 End of session

Classification:Practice

Presenters

MaryLynn Manns
Mary Lynn Manns earned her Ph.D. from De Montfort University in England in the area of introducing software patterns into organizations. Her 25-year teaching experience in academia and industry includes an outstanding teaching award in 1995. She is currently at the University of North Carolina at Asheville where she has taught courses in computer science and management information systems. Her new book is now available--Fearless Change: Patterns for Introducing New Ideas, co-authored with Linda Rising. Mary Lynn has done numerous presentations in industry and academia on the topic of introducing new ideas into organizations.

Linda Rising
Linda Rising has a Ph.D. from Arizona State University. She has been working with object technologies since 1983. She is the editor of A Patterns Handbook, The Pattern Almanac 2000, and Design Patterns in Communication Systems. She has a number of publications and presentations that are all available on her web site: www.lindarising.org. She has presented a number of tutorials and workshops at JAOO, OOPSLA, Agile, and Better Software. Her latest book, co-authored with Mary Lynn Manns is titled: Fearless Change: Patterns for Introducing New Ideas. She has over 25 years of academic and industrial training experience.

Designing Secure Architectures using Security Patterns (Tutorial 34)

Abstract

Patterns combine experience and good practices to develop basic models that can be used for new designs. Security patterns join the extensive knowledge accumulated about security with the structure provided by patterns to provide guidelines for secure system design and evaluation. We consider the structure and purpose of security patterns, show a variety of security patterns, and illustrate their use in the construction of secure systems. These patterns include Authentication, Authorization, Role-based Access Control, Firewalls, Web Services Security, and application-oriented secure architectures for health, legal, and financial applications. We introduce patterns in a conceptual way, relating them to their functions and to the system architecture, pure enumerations are not useful to designers. We show how to apply these patterns through a secure system development method. The patterns are shown using UML models and some examples are taken from my book 'Security Patterns' (Wiley, 2006).

Objectives

Attendees will be able to understand the idea behind security patterns, get acquainted with some of them, and use them to build secure systems.

Tutorial History

This tutorial has been presented at: o University of Buenos Aires, Argentina. Escuela de Ciencias Informaticas (ECI), July 2003. o IEEE Intern. Symp. on Advanced Distributed Systems (ISSADS), Guadalajara, MX, January 2005 and 2006 http://intranet.gdl.cinvestav.mx/issads/ o IEEE Southeastcon, Fort Lauderdale, FL, April, 2005 o Third International Workshop on Security in Information Systems (WOSIS-2005), Miami, May 24-25, 2005 o 5th Latin American Conference on Pattern Languages of Programs, Campos do Jordao, Brazil, August 16-19, 2005 http://sugarloafplop2005.icmc.usp.br/ o IEEE Int. Symposium on Secure Software Engineering (ISSSE.06), Arlington, VA, March 2006. http://www.jmu.edu/iiia/issse/ o IFIP WCC 2006 (Santiago de Chile, August 2006). http://www.wcc-2006.org/program/tc11_security.php?opcion_actual=program o Eigth International Symposium on System and Information Security - SSI´2006, Sao Jose dos Campos, Brazil, November 08-10, 2006. o 45th ACM Southeast Conference (ACMSE 2007), March 23-24, 2007, Winston-Salem, North Carolina, http://acmse2007.wfu.edu o IEEE/IFIP Conference on Software Architecture (WICSA) 2008, February 18-22, Vancouver, BC, http://www.wicsa.net/ o Accepted for the ACM Symposium on Applied Computing, Fortaleza, Ceara, Brazil, March 16-20, 2008.

Audience:Researchers, Practitioners, Educators

Format:Mostly slide-based lecturing. In addition, the instructor will show the detailed structure of a security pattern and will assign an exercise in pattern building.

Classification:Several Areas

Presenters

Eduardo B. Fernandez
Eduardo B. Fernandez (Eduardo Fernandez-Buglioni) is a professor in the Department of Computer Science and Engineering at Florida Atlantic University in Boca Raton, Florida. He has published numerous papers on authorization models, object-oriented analysis and design, and security patterns. He has written four books on these subjects, the most recent being a book on security patterns. He has lectured all over the world at both academic and industrial meetings. His current interests include security patterns and web services security. He holds a MS degree in Electrical Engineering from Purdue University and a Ph.D. in Computer Science from UCLA. He is a Senior Member of the IEEE, and a Member of ACM. He is an active consultant for industry.

Domain-Specific Modeling: Enabling Full Code Generation (Tutorial 35)

Abstract

Domain-Specific Languages and Model-Driven Development have moved from scattered successes, through industry hype, to increasingly widespread practical use. Well-attested benefits include raising the level of abstraction, improving productivity, and improving quality. The main questions are no longer what or why, but where and how. This tutorial will teach participants about Domain-Specific Modeling and code generation, where they can best be used (and where not), and how to apply them effectively to improve your software development. This tutorial introduces DSM and looks at how it differs from modelling languages like UML that focus more on the level of the code world. This is followed by real-life examples of DSM from various fields of software development. The main part of the tutorial addresses the guidelines for implementing DSM: how to choose where to use it, how to identify the domain concepts and formalize them into a metamodel, different ways of building code generation, and how to integrate generated code with legacy or manually-written code. Participants will have the chance to learn practical skills in language creation and modification exercises.

Objectives

Participants will learn how to define modeling languages that enable full code generation from models

Tutorial History

This tutorial has been successfully presented at SPA 2008, Method Engineering 2007, and Software Architect 2007, and accepted to Software Architect 2008. Similar sessions have been presented at around 20 events a year in recent years. The examples and guidelines follow the structure of the presenters' recent book, well-received by the community.

Audience:Researchers, Practitioners, Managers, Educators

Format:Powerpoint slides, language demonstrations "live", language creation tasks

Classification:Practice

Presenters

Juha-Pekka Tolvanen
Juha-Pekka Tolvanen ( This e-mail address is being protected from spambots. You need JavaScript enabled to view it ) is the CEO of MetaCase. He has been involved in domain-specific approaches and tools, notably method engineering and metamodeling since 1991. Juha-Pekka holds a Ph.D. in computer science from the University of Jyväskylä, Finland. He has acted as a consultant world-wide for modeling language and code generation development. Juha-Pekka has co-authored a book (Domain-Specific Modeling, Wiley 2008) and over 60 articles in software development magazines, journals and conferences.

Steven Kelly
Steven is CTO of MetaCase and co-founder of the DSM Forum. He has over fifteen years of experience of tool building and consultancy in Domain-Specific Modelling. As architect and lead developer of MetaEdit+, he has seen it win or be a finalist in awards from SD Times, Byte, Innosuomi, Net.Object Days, and Jolt Productivity. He co-authored the DSM book and over 20 articles in journals such as Dr. Dobb's, and regularly speaks at events like OOPSLA and SD Best Practices. Steven is a member of IASA, on the editorial board of JDM, and plays soccer in the Finnish 3rd division.

Use-Case Patterns and Blueprints (Tutorial 36)

Abstract

Use-case modeling is a well-established technique for capturing requirements stating how a system is to be used. However, many struggle with how to produce complete and correct models and find themselves solving more or less the same modeling problems over and over again. In this tutorial, we show how using patterns and blueprints for use-case models help avoiding these difficulties. We present a collection of useful patterns and blueprints and illustrate how they can be used to facilitate the development of accurate and understandable use-case models.

Objectives

The participants will learn what use-case patterns and use-case blueprints are, and why they are important in use-case modeling. They will learn a collection of use-case patterns/blueprints, how to apply them, and the reasons behind their definitions.

Tutorial History

The tutorial has been given at OOPSLA 2005 and 2007, as well as at the IBM Rational Software Development Conference 2005. The tutorial, including shorter versions, has been given several times to the industry. A neighboring tutorial was given at OOPSLA 2006.

Audience:Practitioners, Educators

Format:The introduction and the conclusion will be done using slide shows. The major part of the tutorial will be a combination of presenting the patterns/blueprints using slide shows and performing an orchestrated modeling workshop using a whiteboard (similar) with the presenters acting as moderators and the participants actively taking part in the modeling effort.

Classification:Practice

Presenters

Gunnar Overgaard
Gunnar Overgaard has been using, mentoring, and teaching use cases as well as participated in the development of the concept since 1987. He has also participated in the development of UML since 1997. Gunnar has given 100s of classes and presentations, both for industry and academia for up to 150 participants. He is one of the authors of the book Use Cases: Patterns and Blueprints, Addison-Wesley, 2004.

Karin Palmkvist
Karin Palmkvist has been working with use cases since the late 1980's, as a system analyst, mentor, teacher, and speaker at conferences and seminars. She also participated in the development and standardization of the UML within the OMG. Karin is one of the authors of the book Use Cases: Patterns and Blueprints, Addison-Wesley, 2004.

Can you be rich and thin? Building Dynamic Web Applications with Seaside (Tutorial 37)

Abstract

Is there a inherent contradiction between a rich client/server application and a thin client? Can a web application provide the control flow that we have come to expect from good desktop applications? Why is it that so many otherwise professionally-developed web sites (including on-line banking, travel reservations, and even the OOPSLA submission system) include warnings like, "Do not save, print or reload this page!" or "Do not use your browser's button!"? Has the web really set programming back to the era of GOTO? Is a basic subroutine call too much to ask from your web framework? Why is it that popular web frameworks devote so much to handling object-relational mapping? While other web frameworks are evolutionary, Seaside has been characterized as revolutionary, even heretical. What makes Seaside different? Is it the funny URLs? Is it continuations? Is it the ability to create reusable domain-specific components? All of the above? This hands-on tutorial will present Seaside (a free, open source, web framework) and walk through the process of building a pure-objects application (UI to database) using GLASS (GemStone, Linux, Apache, Seaside, and Smalltalk). You may bring your own computer or team up with someone else who brought one.

Objectives

Participants will develop a Seaside application and understand how the framework addresses the various web architecture challenges.

Tutorial History

An longer version of this tutorial was presented at Smalltalks 2007 in Argentina.

Audience:Practitioners

Format:This tutorial will combine lecture with hands-on exercises where participants will develop an application following a script provided.

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 and Code Generators (Tutorial 38)

Abstract

In this tutorial, we will capitalize on the DSL we have built in the Textual DSLs - Concepts and Tooling tutorial and show various ways to process the models that can be created with this DSL. 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). The goal of this tutorial is to provide with an understanding of how MDSD code generators work as well as give you a hands-on experience of how to create MDSD model processors that validate, transform and interpret formalized (textual) models in a way that is efficient enough for practical project reality. Please bring your Windows laptop - the tutorial includes hands-on work for you, the participant!

Objectives

Based on a textual DSL that we have developed in the first part of this tutorial series (Textual DSLs - Concepts and Tooling), we will show various ways how to process the models that can be created with this DSL. In order to be processable, models need to be formal and correct. Defining a metamodel (which is, in our case, derived from a language grammar), is one step to ensure formalized models. While the metamodel ensures that its instances (aka models) are valid from a structural point of view, more effort is required to ensure the semantical correctness of the model. Usually, constraints are used to ensure the semantical correctness of the model. We will show how to define and enforce constraints for models at various stages (editing time, generation time) of the generative development chain. Modern software systems are rather complex. Experience has shown that various aspects of software systems should be described by different formalized languages. Structural properties of software systems like components and their relations or the deployment infrastructure might be described in a graphical way to provide an overview of the system. Other aspects of the system such as services and their operations might better be described with textual models. In order to provide a holistical approach to MDSD, it is thus essential to be able to integrate different models of possibly different metamodels. We will show how to achieve this by importing models and metamodels, thus enabling the tooling and the code generator to gain access to an overall view of the model. The ultimate goal of model driven software developent (MDSD) is to use models to drive code generation or interpretation. We will show how to exploit models in this regard by looking at MDSD techniques like model-to-model (M2M) transformations and model-to-text (M2T) transformations. Since some problems are better dealt with in a more dynamic way, we will also take a look at how to process models with an interpreter. So here is what we want the audience to take away: Understand the need for formalized constraints Learn how to integrate various metamodels and models into an MDSD toolchain Understand how MDSD code generators work Learn how to process models using model-to-model transformtions, model-to-text transformations and model interpreters

Tutorial History

This tutorial is new.

Audience:Practitioners, Educators

Format:Some (introductory and reference-style) slides. Most of the tutorial will be hands on. Attendees need to bring their notebooks. Required software will be supplied by the presenters.

Classification:Practice

Presenters

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.

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

Building Memory-Efficient Java Applications (Tutorial 39)

Abstract

It is easy these days to build Java applications with large memory requirements. We commonly see multi-gigabyte heaps with tens of millions of objects, where as much as 80% of memory is the overhead of the data representation. Moreover, problems often show up late in the development cycle, long after important design decisions have been set. This bloat can have a serious impact on deployment. Fortunately, bloated designs are not an inevitable consequence of object-oriented development. This tutorial is a guide to memory-conscious data design in Java. Using documentary examples and a look inside key Java mechanisms, the tutorial aims to empower developers to make informed tradeoffs, and to show how dramatic improvements are sometimes possible with little sacrifice. Case studies are organized by design problem, giving developers a systematic approach to decision making in their own code and in frameworks they use. The tutorial will also raise awareness for development leads, framework designers and other decision makers, of the severity of problems that can occur. Topics covered include memory footprint, temporaries, object lifetime management, and simple strategies for reducing risks. The tutorial does not cover capacity planning, cache sizing, or leaks.

Objectives

An attendee may expect to learn: - A grounding in how data model design and the use of the Java libraries can impact costs - A systematic catalog of design issues to consider in order to achieve efficient use of memory - Some simple techniques that can be incorporated into the development process, so problems can be caught early

Tutorial History

The tutorial was first presented at ICSE 2008, and has been presented at a number of development organizations within IBM.

Audience:Researchers, Practitioners

Format:The tutorial will be lecture-based, drawing heavily on case studies from real-world applications. There will also be some room for discussion, so that everyone can gain from the experiences of the other attendees.

Classification:Practice

Presenters

Gary Sevitsky
Since joining IBM Research in 1998, Gary Sevitsky has been part of a group studying performance and memory usage in large object-oriented systems. The group has developed Java performance and memory analysis tools that have been used extensively on IBM product and customer code. The group has also worked directly on many performance engagements over the past eight years, and has been mining these experiences to catalog the ways in which framework-based systems are often inefficient. Gary has given numerous talks at IBM and universities cataloging problems from case studies and documenting the systemic bloat common in large object-oriented systems.

Software Development and Culture: Learning to Play Together (Tutorial 40)

Abstract

Software development means collaboration, and increasingly this collaboration must cross boundaries of organizational and national culture. Projects in multi-cultural settings involve countless challenges, including not only collaboration, but also everything from existing project planning and management, and even simple communication. Moreover, software development methods might need to be transformed to work at all. The aim of this tutorial is introduce models of culture, and to explore the impact of cultural differences on software development processes and methods, especially novel approaches such as agile development. The tutorial will be organized around two collaborative games to illustrate culture in the software development workplace. The first game, 'Wheel of Culture', involves building and comparing balance wheels that show how organizations vary in their cultural values. The second game, 'Cultural Monopoly' is a novel board game designed by us for small groups to explore the effects of cultural difference on a development project.

Objectives

This tutorial is designed to meet the needs and challenges of software developers working in culturally diverse settings, as well as anyone implementing software methodologies in different cultures. The emphasis of the tutorial is in understanding the role and impact of cultural differences on software processes and methods. The tutorial should facilitate the development of participants' skills to improve effective cross-cultural communication and collaboration in software projects. This tutorial will provide a broad cultural literacy that enhances software projects conducted in multi- cultural settings and facilitate the adoption of new software development practices in different cultures. We will contribute to the understanding of the function of cultures and diversity in a software development environment.

Tutorial History

Originally presented and successful at Agile2007: now refined with more gameplay!

Audience:Practitioners, Managers, Educators

Format:Highly interactive, primarily through gameplay.

Classification:Practice

Presenters

Robert Biddle
Robert Biddle is Professor of Human Computer Interaction at Carleton University in Ottawa, Canada: he is on the graduate faculty of both Computer Science and Psychology. He has degrees in Applied Analysis and Computer Science from the University of Waterloo and the University of Canterbury, and has diplomas in both childhood and adult education. His two main research areas are Software Design and Human-Computer Interaction. His current active research projects are in human issues in software development, novel approaches to computer security, and in the design of interactive media such as videogames, wikis, and end-user development environments.

Claire Dormann
Claire Dormann is a Research Associate in the Human-Oriented Technology lab, at Carleton University in Ottawa, Canada. She has a multidisciplinary background, including a degree in Psychology, a Masters Degree in Computer Science, and a PhD in Communication Studies. She has worked internationally on applied research projects in collaboration with industries. She has been investigating for a number of years how cultural differences impact the ways we develop, design and consume technology. Her interests include: cultural differences, cross-cultural communication and usability, affective computing and the design of innovative applications, as well as software development.

Web APIs on Rails: using Ruby on Rails for Web APIs development and mashups (Tutorial 41)

Abstract

The Web is now programmable. Web sites frequently expose their data and functions as APIs. These APIs take many form of remote invocation of functions and resources (REST), syndication of data feeds (RSS and Atom), and embedable scripts (JavaScript). The Ruby programming language and its Rails framework are ideal for programming Web applications and APIs in Web 2.0. Ruby's modern and dynamic object-oriented features make it an excellent language for rapid prototyping and integration of various Web APIs. Rails' superb support for rapid Web application development, database access, and AJAX, make it well suited for creating front-ends and back-ends to the next generation of Web applications and APIs. This tutorial we will take a hands-on deep-dive into the Ruby and Rails platform. After taking this tutorial you will learn: (1) the basics of Ruby, (2) how to create Web applications backed by a relational database, (3) how to consume and expose Web APIs, (4) how to create and deploy APIs, and (5) how to mashup existing Web APIs and applications to create a new application. This tutorial has been given in various lengths by the same presenter at ICWS/SCC 2006, ICSOC 2007, University of California at Santa Cruz, San Jose State University, and IBM.

Objectives

1) Learn Ruby (basics of the language) 2) Lean Rails (create Rails 2.1 database-backed Web applications) 3) Lean how to expose Web APIs, e.g., REST, Atom, RSS 4) Learn how to consume Web APIs 5) Learn how to mashup Web APIs

Tutorial History

This tutorial (in various lengths) was given at: ‣ San José State University, California, April 2008 ‣ University of California Santa Cruz, February 2007 and 2008 ‣ ICSOC 2007, September, Vienna, Austria ‣ Fujitsu Research Labs, March 2007, Sunnyvale, CA ‣ IBM Guadalajara, November 2006, Mexico ‣ IBM Almaden Research Center, November 2006, San Jose, CA ‣ IEEE SCC/ICWS 2006, September, Chicago, IL

Audience:Researchers, Practitioners, Educators

Format:Slides and live coding and demos

Classification:Practice

Presenters

E. Michael Max Maximilien
Dr. E. Michael Maximilien, (aka "max") is a research staff member at IBM's Almaden Research Center in San Jose, California. Max is a founding member and contributor to three worldwide Java and UML industry standards. Max's primary research interests lie in distributed systems and software engineering, especially Web APIs and services, mashups, social software, Web 2.0, SOA, and Agile methods and practices. Max is active participants and contributor to communities related to Ruby, Ruby on Rails, and Agile methods and practices, inside and outside of IBM. Reach Max via his Web site (www.maximilien.com) and blog (blog.maximilien.com).

Accept Automated Acceptance Testing - Using FitNesse in the Real World (Tutorial 42)

Abstract

Automated Acceptance Testing helps agile teams to ensure both the value of their software and the piecemeal growth of its functionality. It provides a interface between domain experts and developers that formalizes the results of their collaboration. The FitNesse framework has been established as the de-facto standard for acceptance testing. This tutorial teaches developers and testers with programming experience how to start with acceptance testing and utilize FitNesse in their projects efficiently. Participants will develop their own tests and watch them run on their machines.

Objectives

At the end of the tutorials the participants will o Know about the role and importance of acceptance testing o Be able to write simple acceptance tests with FitNesse well enough so they can expand their knowledge themselves later o Be able to write simple Fixtures to couple FitNesse to an application either in Java or C#. The tutorial will teach DoFixtures and ColumnFixtures and give hints on how to use additional Fixture types. o Know the major goals and caveats you have when integrating acceptance tests into the build process and the version management system

Tutorial History

The tutorial is based on an excerpt from a two-to-three-day course on test-driven development given in Germany and Israel several dozen times. The exercises will be based on the proven material with some rework to make it appropriate for an international audience. The three-hour excerpt is new for OOPSLA.

Audience:Practitioners

Format:The tutorial is designed as a set of testing and programming exercises, which the attendees will do on their laptops. It is based on a game of TicToe for which the participants design test cases and implement them using FitNesse Attendees will work in pairs and can choose between exercises in Java and exercises in C#. The structure is planned as follows: 10 minute opening 15 minute introductory lecture and demo: Finding Testcases 15 minute excercise: Finding Testcases 15 minute demo using FitNesse 30 minute exercise: Translating Testcases into FitNesse 5 minute retrospective of exercise Break 30 minute introductory lecture and demo: Fixture coding 30 minute exercise: Fixture programming (code to test is supplied, including bugs to find) 10 minute group debriefing of exercise 15 minute lecture acceptance testing in the build process and version management 5 wrap-up

Classification:Practice

Presenters

Jens Coldewey
Jens Coldewey ( This e-mail address is being protected from spambots. You need JavaScript enabled to view it ) is an independent consultant from Munich, Germany, specialized in deploying agile development. He was program chair of the EuroPLoP '98 conference, member of the program committee of the numerous conferences, among them PLoP, EuroPLoP, Agile Development Conferece, Agile and OOPSLA 2003, 2004 and 2006. He is founding member and was board member of the Agile Alliance Non-Profit Organization and is member of the Agile Project Management Practice of the Cutter Consortium, Cambridge, MA. He is using FitNesse in projects for more than two years and has taught a number of tutorials on test-driven development.

Johannes Link
Johannes Link ( This e-mail address is being protected from spambots. You need JavaScript enabled to view it ) is an independent consultant and coach from Heidelberg, Germany, specialized in agile and test-driven development. He has been practicing and teaching TDD for almost ten years and is author of the book "Unit Testing in Java: How Tests drive the code" (Morgan Kaufmann, 2003). Johannes is developer of the ReFit program to refactor FitNesse tests. Johannes is a frequent speaker at conferences, including JAX and XP Days Germany, PC member at numerous conferences on agile and has been conference chair of the XP Days Germany 2007.

Fault Tolerant Software with Patterns (Tutorial 43)

Abstract

We rely more and more computer software to conduct our business, maintain our links with society and enhance our lives. We want those computer systems, whether they are web servers, ATMs, the internet or the phone system, to be ready to process our requests when we want them. But we are the people creating these systems; so we should know something about basic principles of fault tolerance. Fault tolerance is something that is designed into software systems. It is not free and it is more than a way of coding or a quality methodology. The ability to tolerate faults is important to computer systems because it allows them to detect, isolate, contain and process errors at runtime before they cause the system to fail. This tutorial looks at designing software to be fault tolerant. There are many techniques that individual architects and designers can put into their software allowing it to tolerate faults. These techniques have been used in many systems, from many different application domains, for many years. This tutorial lays the foundation for fault tolerant design. It starts with the basics and progresses to defining key design elements for fault tolerant software. A pattern-based approach is used.

Objectives

Attendees will understand the three main parts of fault tolerance (detection, recovery and treatment). They will also be able to describe patterns that help design fault tolerant systems.

Tutorial History

This tutorial was presented at OOPSLA 2007 in Montreal. It is an outgrowth of a 2003 OOPSLA tutorial.

Audience:Practitioners

Format:The presentation format consists of a variety of lecture, discussion and scenario walkthrough

Classification:Practice

Presenters

Robert Hanmer
Robert S. Hanmer is a Consulting Member of Technical Staff at Alcatel-Lucent. Current responsibilities include developing software-sourcing strategies for a number of technologies including availability-enhancing middleware. Previous positions within Lucent Technologies and Bell Laboratories have included development and architecture focusing on the areas of reliability and performance. He is active in the software patterns community, including serving as program chair at several pattern conferences. He is a member of the IEEE Computer Society, the Hillside Group, and is a Senior Member of the ACM. He received his B.S. and M.S. degrees in Computer Science from Northwestern University in Evanston, Illinois.

Project Retrospectives (Tutorial 44)

Abstract

Project Retrospectives can be a vital part of any software development project. In Agile development, one of the Principles Behind the Agile Manifesto states that, 'At regular intervals, the team reflects on how to become more effective, then tunes and adjusts its behavior accordingly'. How can this be done? This tutorial will present techniques for facilitating project retrospectives. Attendees will learn how to help their teams discover what they're doing well so that successful practices can continue and identify what should be done differently to improve a team's performance. Retrospectives are not finger-pointing sessions, but rather a highly effective series of activities in which teams reflect on the past in order to become more effective in the future. Participants will be introduced to the retrospective process, learn techniques for leading retrospectives, hear the experiences of the tutorial leaders who have led retrospectives for numerous projects, and have the opportunity to participate in a retrospective simulation.

Objectives

Participants will understand the benefits of retrospectives, the concepts and philosophy underlying the approach, and be aware of several approaches for conducting exercises on their own projects. They will experience a retrospective simulation and apply various techniques and exercises. The session will give participants the information they need to begin leading retrospectives. They will also learn how to sell the idea to colleagues and managers and to show the importance of applying retrospectives to projects.

Tutorial History

Both presenters initially worked with Norm Kerth to present the tutorial at OOPSLA '01. They have developed their own style but rely heavily on his expertise and his book, Project Retrospectives for which they were both reviewers. Both presenters have given this tutorial many times, both in academia and industry, including the following: OOPSLA'03, 2003 Agile Development Conference, Pace University Doctorate of Professional Studies Program (several years), and JAOO (several years). A retrospective is always performed by the presenter(s) after each session, so that the tutorial continues to improve based on our experience and the feedback from the participants.

Audience:Researchers, Practitioners, Managers, Educators

Format:After an introductory lecture (with slides), the group will participate in an exercise that will simulate a retrospective. The tutorial is a combination of lecture, exercise, simulation of key parts of a retrospective, and group question and answer. It is a highly interactive session. Proposed format: 00:00 Introductions and discussion of what participants hope to gain from the session. 00.15 Lecture and discussion. Overview of the retrospective process. 01.30 Break 01.45 Retrospective simulation. 03.15 De-brief. Summary of the session. 03.30 End of session.

Classification:Practice

Presenters

Linda Rising
Linda Rising has a Ph.D. from Arizona State University in the area of object-based design metrics. Her background includes university teaching experience as well as work in industry in the areas of telecommunications, avionics, and strategic weapons systems. She has been working with object technologies since 1983. She is the editor of A Patterns Handbook, The Pattern Almanac 2000, and Design Patterns in Communication Systems. She has a number of publications and presentations that are available on her web site: www.lindarising.org. She has presented a number of tutorials and workshops at JAOO, OOPSLA, Agile, and Better Software conferences. She has experience leading retrospectives in a number of companies and academic settings around the world, as well as giving presentations on the benefits of retrospectives. She has over 20 years of academic teaching experience and over 15 years of industrial training experience.

Mary Lynn Manns
Mary Lynn Manns earned her PhD from De Montfort University in England in the area of software patterns. Her 25-year teaching experience in academia and industry includes an outstanding teaching award in 1995. She is currently at the University of North Carolina at Asheville where she has taught courses in computer science and management information systems. She is co-author of the book with Linda: Fearless Change: Patterns for introducing new ideas. Mary Lynn has led numerous seminars on project retrospectives for both academia and industry.

Introduction to Model Driven Development with examples using Eclipse Frameworks (Tutorial 45)

Abstract

Model Driven Engineering (MDE) brings together multiple technologies and critical innovations and formalizes them into the next wave of software development methods. This tutorial will cover the basics of MDE and how they work synergistically with Generative Software Development (GSD) techniques and Component Frameworks (CFs). The three main MDE categories include the development of Domain Specific Languages (DSLs), Domain Specific Editors (including Domain Specific Visual Languages) and, Domain Specific Transformation Engines or Generators. Expressed in terms of language development technology, these mirror the development of the Abstract Syntax, Concrete Syntax and Semantics of a new DSLs. It will cover the basic effective patterns, principles and practices for using MDE and GSD. Additionally, as a powerful example, this tutorial will cover the exact details of how to leverage the Eclipse Modeling Framework (EMF), the Eclipse Graphical Editor Framework (GEF), and the Eclipse Graphical Modeling Framework (GMF), to support the development of DSLs. These frameworks provides a unique and integrated platform in which to learn the basics of MDE and GSD in application. Conversely, MDE and GSD provide an effective context in which to learn how to apply the power of these integrated Eclipse Frameworks developed to support MDE and GP.

Objectives

To convey modern modeling techniques that will allow attendees to effectively raise the level of abstraction in their complex domains while not sacrificing semantic rigor and precision or performance.

Tutorial History

This tutorial has been successfully delivered at conferences throughout the world and has been asked back numerous times. 1. MODELS 2007 - http://models2007.isis.vanderbilt.edu/tutorials.html 2. MODELS 2006 - http://www.disi.unige.it/researchsites/models06/tutorials.php - This was the highest attended tutorial at MODELS 2006 3. EclipseCon 2008 - A version of this tutorial has been accepted and is scheduled to be delivered at EclipseCon 2008 - http://www.eclipsecon.org/2008/?page=sub/id=282 4. EclipseCon 2007 - A lightning talk on this technology was well received at - http://www.eclipsecon.org/2007/index.php?page=sub/id=4177 5. SPLC 2007 - http://splc2007.jaist.ac.jp/T14.html 6. SPLC 2006 - http://www.sei.cmu.edu/splc2006/tutorials.html#T5 7. TOOLS 2007 - http://tools.ethz.ch/tools2007/callfortutorials.html 8. OOPSLA 2006 -http://www.oopsla.org/2006/submission/tutorials/gpce_1:_model_driven_development_basics_using_eclipse.html 9. GPCE 2006 - http://www.program-transformation.org/view/GPCE06/TutorialGPCE1?skin=print.pattern

Audience:Researchers, Practitioners, Managers, Educators

Format:Part Theory, Part Practical and Hands-on. The format is very flexible depending on who attends

Classification:Practice

Presenters

Bruce Trask
Bruce Trask has been working on complex Distributed Real-Time Embedded systems for over 20 years specializing in MDE, GSD and Component Frameworks and Engineering. He has developed commercial quality MDE tools, Component Architectures and Frameworks as well as Generative Engines for many complex domains. He has been teaching C++, Object Orientation, Design Patterns, UML, CORBA and Framework courses for over 10 years. He has lead multiple study groups in the New York, New Jersey, Connecticut area on various topics ranging from design patterns to middleware. He is a regular speaker/presenter at software industry conferences all year long. He has delivered tutorials at the OMG. Bruce Trask is the CEO of MDE Systems.

Angel Roman
Angel Roman is the Chief Software Architect of MDE Systems and an expert on the Eclipse Development environment and its application frameworks. He has presented at various industry conferences on topics such as Software Defined Radios and MDE Technologies.

Programming in Scala (Tutorial 47)

Abstract

Scala is a new general-purpose programming language that is fully interoperable with Java. It smoothly integrates features of object-oriented and functional languages. Scala allows a terseness of style comparable to scripting languages but has at the same time a strong and static type system. In this way, it can express common programming patterns in a concise, elegant, and type-safe way. Scala also allows for creation of Domain-Specific Languages that hide much of the complexity of traditional APIs from users. Combined with its ability to plug into existing Java environments, this makes it possible to construct higher-level interfaces to existing Java libraries (servlets, Spring beans, EJB, Swing, and more). Its Actors-based threading approach, combined with its functional preference for immutable values makes concurrent programming far simpler than what's present in Java. And its built-in XML support makes Scala natural for XML processing tasks, including Web Services. This tutorial will give an introduction to the Scala programming language, highlighting its main innovative features: closures, pattern matching, type abstraction, and mixins.

Objectives

Attendees will leave with an introductory understanding of core Scala features, and its unique blend of functional and object-oriented programming support.

Tutorial History

Based on the tutorial given previously at OOPSLA by Martin Odersky.

Audience:Researchers, Practitioners, Managers, Educators

Format:Slides

Classification:Several Areas

Presenters

Bill Venners
Bill Venners is president of Artima, Inc., publisher of Artima Developer (www.artima.com). He is a co-author of the upcoming book, Programming in Scala, and is author of the book, Inside the Java Virtual Machine, a programmer-oriented survey of the Java platform's architecture and internals. His popular columns in JavaWorld magazine covered Java internals, object-oriented design, and Jini. Active in the Jini Community since its inception, Bill led the Jini Community's ServiceUI project, whose ServiceUI API became the de facto standard way to associate user interfaces to Jini services. Bill is also the lead developer and designer of ScalaTest, an open source testing tool for Scala and Java developers.

Introduction to Google Guice and testing with GuiceBerry (Tutorial 48)

Abstract

Guice (pronounced 'juice') is a lightweight dependency injection framework for Java 5 and above, brought to you by Google. Put simply, Guice alleviates the need for factories and the use of "new" in your Java code. Think of Guice's @Inject as the new "new". You will still need to write factories in some cases, but your code will not depend directly on them. Your code will be easier to change, unit test and reuse in other contexts. In the first half of this session, we'll introduce you to Guice and compare it to classical approaches like the factory pattern and the service locator pattern. In the second half of this session, we'll show you how to test Guice applications using GuiceBerry.

Objectives

Learn how to use Guice to make your code more concise and flexible.

Tutorial History

New tutorial

Audience:Practitioners

Format:Slides

Classification:Practice

Presenters

Bob Lee
Bob Lee created the Jolt award-winning Guice framework and currently leads the core library development on Android. He blogs about Java at http://crazybob.org/.

Luiz-Otavio Zorzella
Zorzella is GuiceBerry's primary author, a lead engineer in Google's AdWords FrontEnd, and a pioneer in the Guice-fication of the code, being one of the first customers of Guice, before its public release. He has over 10 years experience with Java, having begun working with the language since before its 1.0 release.

GPCE: Effective Model Driven Engineering to Create Domain Specific Languages (Tutorial GP1)

Abstract

Model Driven Engineering (MDE) brings together multiple technologies and critical innovations and formalizes them into the next wave of software development methods. This tutorial will cover the basics of MDE and how they work synergistically with Generative Software Development (GSD) techniques and Component Frameworks (CFs). The three main MDE categories include the development of Domain Specific Languages, Domain Specific Editors (including Domain Specific Visual Languages) and, Domain Specific Transformation Engines or Generators. Expressed in terms of language development technology, these mirror the development of the Abstract Syntax, Concrete Syntax and Semantics of a new Domain Specific Languages (DSLs). This tutorial will cover the basic effective patterns, principles and practices for developing these MDE and GSD software artifacts. Additionally, as a powerful example of these concepts in action, this tutorial will cover the exact details of how to leverage the Eclipse Modeling Framework (EMF), the Eclipse Graphical Editor Framework (GEF), and the Eclipse Graphical Modeling Framework (GMF), to support the development of powerful DSLs and their tools. These three frameworks provides a unique and integrated platform in which to learn the basics of MDE and GSD in full application. Conversely, MDE and GSD provide an effective context in which to learn how to apply the power of these integrated Eclipse Frameworks developed to support MDE and GP.

Objectives

Information not available

Tutorial History

Information not available

Audience:The benefits of the technology are so far reaching that we feel the intended audience spans technical managers, developers and CTOs. In general the target audience includes researchers and practitioners who are working on complex problems related to the design and implementation of any complex domain and would like to understand the benefits of applying MDE techniques towards GSD and leverage existing tools and frameworks (i.e. Language Workbenches) to develop MDE solutions. The first half will be less technical than the second half where we cover the details of MDE and GSD in action in complete detail showing patterns and code. Attendees will come away with an appreciation for how they can effectively raise the level of abstraction in their domains without sacrificing the semantic rigor and precision needed for correct and robust systems.

Format:Information not available

Classification:GPCE

Presenters

Bruce Trask
Bruce Trask has been working on complex Distributed Real-Time Embedded systems for over 20 years specializing in MDE, GSD and Component Frameworks and Enginnering. He has developed commercial quality MDE tools, Component Architectures and Frameworks as well as Generative Engines for many complex domains. He has been teaching C++, Object Orientation, Design Patterns, UML, CORBA and Framework courses for over 10 years. He has lead multiple study groups in the New York, New Jersey, Connecticut area on various topics ranging from design patterns to middleware. He is a regular speaker/presenter at software industry conferences all year long. He has devlivered tutorials at the OMG. Bruce Trask is the CEO of MDE Systems.

Angel Roman

Angel Roman is the Chief Software Architect of MDE Systems and an expert on the Eclipse Development environment and its application frameworks. He has presented at various industry conferences on topics such as Software Defined Radios and MDE Technologies.

Bruce and Angel have an experience published in Software Product Lines, 10th International Conference, SPLC 2006, Baltimore, Maryland, USA, August 21-24, 2006, Proceedings. IEEE Computer Society 2006, ISBN 0-7695-2599-7.

GPCE: Problems We Can Solve with Power-Generics (Tutorial GP2)

Abstract

Repetitions are common in software. Genericity is a prime strategy to avoid repetitions. STL is a hallmark example of benefits that can be gained by exploiting software similarities and representing them in generic form. Can we replicate STL success in other application domains, e.g., business systems, in which we also observe much similarity?

The concept of power-generics addresses this question, trying to reach beyond what we can achieve with conventional generic design mechanisms, such as type-parameterization. The goal of power-generics is to let a programmer avoid redundancies whenever a programmer wishes to do so. The basic requirement for power-generics is to represent in a generic form any group of similar program structures of any kind and granularity, from similar classes, to recurring similar patterns of collaborating classes/components, to modules and subsystems.

Why are such power-generics useful and interesting? Power-generics let us exploit the benefits of non-redundancy and simplification in any domain where we observe substantial repetitions. They also open a sea of new possibilities for software engineering methods, in particular for software reuse via Product Line approach. Reuse goal is to exploit similarities in a family of software systems to boost productivity. Power-generics can help us build generic representation for a family of similar systems, extending the reuse capabilities of current Product Line Architectures based on components and architectures, whereby genericity is applied only in ad hoc way. In this context, power-generics have a role to play in defining effective strategies for variability management in Product Lines, and extending reuse benefits from product development to its evolution (maintenance).

The concept of power-generics creates a much missed bridge between programming language mechanisms and software engineering goals, such as reusability or maintainability.

In this tutorial, we bring power-generics from the concept to realization. Our solution is based on meta-level program decomposition, unrestrictive parameterization, and generation. It is realized by simple transformations at a meta-level program representation, with XVCL technique (XML-based Variant Configuration Language, xvcl.comp.nus.edu.sg).

XVCL program transformations are text-based, and have no regard to the rules of the underlying programming language. This makes validation of transformations in conventional sense difficult, if not impossible. A programmer has to understand a meta-program, as well as a concrete program, and properly relate one to another. He/she has to debug the program derivation process, as well as a concrete program.

On the other hand, power-generics with XCL bring attractive and unique engineering benefits, in terms of improved maintainability, reusability and software complexity management, in general. These benefits have been confirmed in industrial applications and lab studies. Empirical and analytical studies shed light on the sources of the observed benefits, as well as trade-offs and limitations involved in our realization of the power-generics concept. The also explain the difficulties of realizing power-generics with programming language mechanisms, as well as with component-based and architectural approaches.

In the tutorial, we discuss advantages and compromises involved in realizing power-generics with techniques such as XVCL. We revisit the issue of programming language support for software engineering goals. We compare XVCL with related approaches such as AOP, FOP and Java annotations. We also discuss automated detection in software systems of large-granularity similar program structures, as candidates for power-generics solutions, so-called structural clones.

Objectives

Information not available

Tutorial History

Information not available

Audience:The audience should have basic understanding of software design and development. No prior knowledge of a specific programming technologies is required. The target audience includes academic faculty, students and researchers, software practitioners, project leaders, analysts and designers.

Format:Information not available

Classification:GPCE

Presenters

Stan Jarzabek
Stan Jarzabek is an Associate Professor at the Department of Computer Science, School of Computing, National University of Singapore. He spent 12 years of his professional career in industry and 20 years in academia. Stan is interested in all aspects of software design, in particular techniques for design of adaptable, easy to change (high-variability) software. He is an author of a book Effective Software Maintenance and Evolution: Reuse-based Approach, Taylor & Francis CRC Press, 2007, and published over 90 papers in international journals and conference proceedings (his recent paper received the ACM Distinguished Paper Award). Stan was a Principal Investigator in a multi-national collaborative project involving universities (NUS and the University of Waterloo) and companies in Singapore and Toronto.

GPCE: Multi-stage Programming in MetaOCaml (Tutorial GP3)

Abstract

Multi-stage programming is a paradigm for writing generic programs that do not pay a runtime overhead. The key underlying technology is program generation. In addition, languages designed to support this paradigm (such as MetaOCaml) help the programmer avoid many of the difficulties that are traditionally encountered in developing program generators. This tutorial will introduce you to the basics of this paradigm as well as of programming in MetaOCaml. Numerous examples will be used to illustrate the practice of multi-stage programming.

Objectives

Information not available

Tutorial History

Information not available

Audience:The tutorial level is introductory (requires almost no experience with any specific programming language). Familiarity with OCaml would be helpful, but is not essential. Familiarity with a genericity and higher-order typing would be useful, but is not necessary.

Format:Information not available

Classification:GPCE

Presenters

Walid Taha
Walid Taha lead the development of the semantics of staged computation, type systems for multi-stage languages, and implementing multi-stage languages like MetaOCaml and MetaOCaml Concoqtion. Currently, he leads the Resource-aware Programming (RAP) research group at Rice University, Houston, TX. He is the principal investigator on a number of NSF, Texas ATP, and SRC research grants and contracts on various aspects of resource aware programming. Taha is actively involved in development of both the embedded software and generative programming research communities.