Tutorial: Design by Contract in Java

Richard Mitchell, InferData Ltd and Mitchell Horvath Ltd
Design by Contract involves adding contracts to classes and their methods. These contracts are between those who implement classes and those who write clients of classes. The contracts are expressed as assertions (preconditions, postconditions, and invariants). Good contracts improve documentation and help with testing.

The six principles covered in the tutorial will help you write good contracts. The tutorial will also help you understand the relationship between contracts and exceptions.

Workshop: Designing Collaborative Workspaces

Mike Hill, Mandu Limited and Rachel Davies, Agile Experience Ltd
One of the key success factors in Agile projects is the workspace environment. Does the workspace facilitate or hinder collaboration? For example, is there a wall that can be turned into an information radiator? Which team members should sit next to each other? Are there frequent interruptions? Does the workspace meet health & safety requirements?

In this workshop, we will explore issues of project workspace design. By creating the "workspace from hell" and the "workspace from heaven", we will identify key aspects of both successful and unsuccessful environments. For hellish environments we will investigate how we can workaround the difficulties; for heavenly environments will we identify weaknesses.

Tutorial: Serious Javascript

David Harvey, Sibelius Software and Peter Marks, Digita
JavaScript is probably the world's most underrated language.

It is certainly the most ubiquitous, with at least one runtime environment on almost every personal computer and mobile phone on the planet. It is the language of most client-side web interactivity in DHTML and Flash. It is preinstalled as a shell scripting language on all modern Windows machines and is optional on OSX and Linux.

It is simple to learn, has a small core library, requires only a small, simple runtime and is easily embedded. It's standard is controlled by ECMA and evolves at a reasonable pace. Implementations follow the standard providing usually only small extensions. It has reasonable tool support that is improving quickly and many platforms now have debuggers that provide dynamic evaluation.

... but none of this is why we believe it should be taken more seriously. It deserves the attention of SPA participants because it is actually a pretty good language. It has gotten a bad rap because many of the platforms on which it runs are crappy and because there is great variation between platforms that should be compatible, but this is not the fault of the language.

This tutorial will introduce the language from a real programmer's perspective (rather than as a gimmick for wizzy web pages). We will cover, dynamic typing, the prototypical object model, lexical scoping and the core library. We will point out some warts of the language and highlight some "gotchas". We will then show how some advanced programming techniques such as higher-order programming, currying and monads can be implemented in JavaScript and discuss where such ideas might be used.

With the rise of AJAX, the emergence of Rich Client tools such as Open Lazslo and Flex, and even server-side platforms like Helma, JavaScript is being used in serious commercial systems. This tutorial will provide a solid foundation for learning the language and give insight into how it might be used expressively and creatively.

Case study: From English to Executable Rules

Christian Nentwich, Model Two Zero and Robert James, HSBC
This case study will discuss how we used model-driven techniques to improve the implementation, documentation and maintainability of a process orchestration system at HSBC.

The session will provide a brief introduction to the Natural Rule Language (NRL), an open language published on sourceforge, and how we added an action language on top of the constraint language that it provides. It then discusses how we parse and map the language, and in more detail the issues we found when mapping it to the JESS rule engine for execution.

Our approach addressed a number of critical requirements, including: the need for readability of business rules, which are hard to maintain in their rule engine execution format; documentation that is more easily reviewed by non-technical people; the ability to target other execution environments (for example Java) without changing the specification.

The goal of the session is to make participants aware of the work being done to complement UML's modeling power with a constraint and action language that is genuinely readable, and which is already mapped to a target execution language (JESS). Also to flag some of the issues we found when doing this in practice.

Tutorial: Test Driven Development with JMock2

Romilly Cocking, Cocking and Co. Ltd., Andy Pols, Pols Consulting Limited and Nat Pryce, B13 Services
JMock has become the de facto standard for developers who want to use mock objects on Java projects.

In this session developers will learn how to design and implement simple and informative unit test using the latest version of the JMock open source library.

This is a practical session in which you will design and implement unit tests for a realistic case study.

Simulation: The Scoping Game

Mark Dalgarno, Software Acumen
Software Reuse offers productivity, quality and time-to-market benefits. However, deciding what software should be made reusable can be difficult. Software Product Line research has provided an answer to this question in an activity called Scoping. Scoping determines what features should be made reusable and in what ways by placing values and costs on features of the Product Line.

The Scoping Game introduces and explores Scoping through playing a simple game. Scoping is a social as well as an economic activity and many stakeholders are involved. This session will prepare participants for some of the issues that they may encounter in a real scoping exercise when trying to satisfy the competing goals of a large group of stakeholders.