Keynote
Mary Poppendieck will talk about a topic relevant to the Agile community.
Lean Development Tutorial *
The Lean Software Development tutorial, identifies seven fundamental “lean” principles, adapts them for the world of software development, and shows how they can serve as the foundation for agile development approaches that work. Along the way, you will discover 22 “thinking tools” that can help you customize the right agile practices for any environment.
Better, cheaper, faster software development. You can have all three—if you adopt the same “lean” principles that have already revolutionized manufacturing, logistics and product development.
Iterating towards excellence: software development as an exercise in discovery
Managing uncertainty: “decide as late as possible” by building change into the system
Compressing the value stream: rapid development, feedback, and improvement
Empowering teams and individuals without compromising coordination
Software with integrity: promoting coherence, usability, fitness, maintainability, and adaptability
How to “see the whole”—even when your developers are scattered across multiple locations and contractors
Simply put, Lean Software Development helps you refocus development on value, flow, and people—so you can achieve breakthrough quality, savings, speed, and business alignment. For an outline of the tutorial, go to: http://www.leantoolkit.com/leantutorial.htm
Introduction to XP
This session provides an introduction to eXtreme Programming, XP. A full overview of XP values and practises with examples of how they are applied. Using a real user story from a current development project, Sean Hanly will give the "Story of a Story" - from initial user story presentation, estimation, scheduling, delivery of acceptance tests, and implementation through "Test Driven Development".
Management Perspective on Agile Development
A session giving an overview of strengths and weaknesses of XP and Agile development practises from a management viewpoint.
XP for Embedded Software
We'll look at the ways that embedded development is different from other kinds of software development, what that means for toolchains, and for Test Driven Development. A range of embedded systems experience from mobile phone applications to scientific instruments provides the backdrop for examples we will give. The intended audience is software developers who anticipate doing embedded work in future, as well as those now engaged in embedded development. The focus will be on how embedded work is different and what benefits XP brings to it.
Customer Role
XP is often described from the Developer perspective. This session talks about the role of the on-site customer in XP and how to go about writing user stories, making clear how they are different from Use Cases and traditional requirements documents.
Metrics
Steering by Numbers - Do metrics make any sense on an agile project? Are there any metrics that make steering an agile project easier? Can you really manage what you do not measure?
Continuous Integration with Cruise Control
CruiseControl.NET is an automated integration server designed to handle the integration needs of .NET projects. In this presentation we describe how CC.NET helps teams practice continuous integration. We present the project's latest enhancements, and demonstrate how to set up a CC.NET server and various CC.NET tools, such as CCTray and CCWeb.
XP Game
The XP Game is a playful way to familiarize the players with some of the more difficult concepts of the XP Planning Game, like velocity, story estimation, yesterday’s weather and the cycle of life. Anyone can participate. The goal is to make development and business people work together, they both play both roles. It’s especially useful when a company starts adopting XP.
Panel
An opportunity to ask questions of a panel of XP and Agile experts.
Coaching Techniques
The role of ‘Team Coach’ is new to software development, and more and more companies are appointing coaches to work with their teams. But what is a coach, and what are the skills that a good coach needs?
Although coaching is new to software development, the profession of life coaching and executive coaching has been growing for the last three decades, and coaching for sports teams has been around for centuries. There is now a substantial body of knowledge on the skills and techniques that are needed by a good coach. In this workshop participants will learn and practice ten core skills for effective coaching.
Acceptance Test Driven Development
It is important for a team to know when work is complete. It is no good if the development team thinks a story is done only to later find that in the customer's eyes, it's 'not quite what I had in mind'. We, as team, need a clear picture of what is required and know when we are done.
ATDD addresses these problems by putting acceptance tests back at the centre of the process and using them as a means for not only specifying requirements but also as a vehicle we can use for driving out development tasks. We augment the planning process with a pre-planning stage which we call "Getting our Story Straight"; we use this time to work with the customer (and our QA) to write acceptance test for the candidate stories for the iteration which is just about to start. By scripting the tests before the planning session, we define the requirement in terms of its function and the expected external quality.
How is this approach different from traditional XP? Using ATDD, every iteration starts with a set of runnable acceptance tests and progress can be measured directly against the pass state of these tests.
SCRUM + XP
Scrum, one of the agile processes, has been used to develop systems and products since 1995 on thousands of projects in hundreds of organizations. Scrum implements in several days and delivers increments of functionality within thirty days. Scrum wraps existing engineering practices. This session compares Scrum and XP contrasting their strenghs.One of the interesting things about both XP and Scrum is that they're both explicit about the areas that the other process is vague in. Although the processes complement each other quite well, there is still quite a bit of fine-tuning that needs to be done to get them to mesh, and not mess, with each other.
Enablement Patterns
Agile enablement is the process of changing a traditional business to work in an agile way. By this we mean doing less up front planning in exchange for regular feedback and tracking of status. This allows an enterprise to adapt better to changing requirements and environment.
Whilst working with various clients in large and small teams and in large and small enterprises, we have come across a number of behavioural and organisational patterns which in the context of Agile development methods we term Enablement Patterns. In the session we will discuss our findings - the patterns we discovered - and attempt to challenge and expand on this base set.
Keynote
Martin Fowler will talk about a topic relevant to the Agile community.
Test Driven Development
Test Driven Development (TDD) is a way of writing code that produces clean, concise and well tested code. It is different than the way most people are taught to develop code, and takes some getting used to. This tutorial gives participants a hands-on introduction to TDD in which they can get a flavour of how it works. XUnit/Mock and sample code will be provided for the exercises in two languages: Java and Python. Participants can use whatever language they want but no sample code or infrastructure support can be given for other languages.
This session has a limit of 25 places. You will need to bring a laptop with you, presenters will advise you on software setup required. Please indicate your programming language preference.
An Introduction to EnterpriseXP: Removing the Resistors to XP
One of the great resistors to the introduction of Agile methods, particularly XP, in many organisations, is that it can be perceived as just addressing the needs of the developers and ignoring the project management and governance aspects. However, if Agile developments are introduced within a proven management and application development framework totally focussed on the business priorities and benefit realisation, these resistors to change can be overcome. EnterpriseXP blends the proven benefits of DSDM's project management Framework and business focus with XP's efficiency and high quality development practices. This presentation will demonstrate how EnterpriseXP provides the rigour and control for management without the bureaucratic elements, which would inhibit the benefits of XP.
Developing an Acceptance Testing Framework
When introduced to the concept of automated acceptance testing, especially driving development from this perspective, most people get it straight away. However, this enthusiasm tends to be short-lived and is followed by questions such as yeah, "but it would take us months to create such a framework", "but our legacy FOO system is untestable", [add more questions here].
In this presentation Sean Hanly will share his experience in developing and implementing AT frameworks that have had to overcome these and other questions. This will not only cover the tools required but also the approaches required given different organisational constraints.
This presentation will be of particualr interest to Developers, Testers and Customers. Significantly, Testers will find this presentation of interest since it offers concrete approaches for a task that they are given very little guidance on with the current XP literature.
Acceptance Tests vs Unit Tests
This session examines the difference from a developer's perspective between Acceptance Tests and Unit Tests.
Retrospectives
This tutorial will present techniques for facilitating project and heartbeat retrospectives that allow teams to discover what they’re doing well so that their successful practices can be repeated and what they’re not doing as well so that they can discuss how to improve. Retrospectives are not “finger pointing” sessions, but rather a fun and highly effective series of activities in which teams can reflect on the past in order to become more effective in the future. Participants will be introduced to the retrospective process, learn various techniques for leading retrospectives, hear the experiences of the tutorial leaders who have led retrospectives in various kinds of projects.
Tracer Bullets
"There are two ways to fire a machine gun in the dark. You can find out exactly where your target is (range, elevation, azimuth) and the environmental conditions (temperature, humidity, air pressure, wind), determine the specification of the cartridges and bullets and the actual gun you are firing. You can use tables to calculate the exact bearing and elevation of the barrel and then, if the environment doesn't change, your bullets should land close to their target. Or you could use tracer bullets. Tracer bullets are loaded at intervals in the ammo belt alongside regular ammunition. When they're fired their phosphorus ignites and leaves a pyrotechnic trail from the gun to whatever they hit." -- quoted from The Pragmatic Programmer
It's not about hitting a target, but rather constantly checking that you are heading in the right direction. It is better to try early and take small steps to improve your aim.
In this workshop attendees will experience an extreme simulation of building software using the principle of extensive feedback and evolution, which is at the core of XP. Teams will have to build a product from things like wood, sticky tape and pins in a non-software game within a short timeframe.
In our experience of working within agile teams, we have found that it is just as important to apply the principle of extensive feedback and evolution to the development process as it is to the software itself. We have found that a team applying XP will use the core practices as a recipe to create a specific XP flavour within its environment, and use feedback to adjust this recipe.
The workshop is structured so that we investigate and apply this principle and, through coaching and reflection, we expect to draw conclusions that show how to make the process itself as agile as the software developed.
Responsibility Driven Design
Developed by Rebecca Wirfs-Brock, et al., Responsibility Driven Design (RDD) is a software development method that, like XP, has its origins in the Smalltalk community.
In the OO world, there are a number of TLA's that have been bandied about since the early days of black-and-white monitors, which are still used today, and where many of those using these terms don't really have any idea what they really mean and represent. MVC - ModelViewController - is one. Another is CRC - Class-Responsibility-Collaborator - an agile modeling technique used in RDD.
Whether using an agile development process or not, the creation of a consistent, stable and maintainable object-oriented software architecture requires a systematic analysis and design. The definition of key classes, subsystems and hierarchies has a fundamental influence on the quality of the software and the degree of reusability. Responsibility Driven Design provides an easy-to-understand and effective method of doing this.
This workshop will deal with established analysis and design principles. In it, JosephPelrine will give an overview of CRC in the context of OO-Design in general, and RDD in particular, and will have participants ante up for a number of CRC card games.
MockObjects
Mock objects are usually regarded as a programming technique that merely supports existing methods of unit testing. But this does not exploit the full potential of mock objects. Fundamentally, mock objects enable an iterative, top-down development process that drives the creation of well designed object-oriented software.
This tutorial will demonstrate the mock object development process in action. We will show how using mock objects to guide your design results in a more effective form of test driven development and more flexible code; how mock objects allow you to concentrate more on end-user requirements than on infrastructure; and how the objects in the resultant code are small and oosely coupled, with well-defined responsibilities.
Includes:
* Brief introduction to mock objects and the dynamic mock API.
* The mock object design process explained.
* Top down vs. bottom up design.
* What to mock. And what not.
Please note the organisers reserve the right to make changes to the programme and speakers, or to cancel sessions if enrolment criteria are not met or when conditions beyond our control prevail.