 |
 |
||
 |
|||
| |
|
||
|
|||
TUTORIAL 1.2: User Stories and the Planning Game
Expected audience:
Programmers, although managers and customers will also benefit.
Required experience:
Have read Extreme Programming Explained
Abstract:
Kent and a special guest will lead the participants through
the basics of programming extreme:
Some of the topic will be covered by demonstration, others by exercises. We will use JUnit as our example project. Our goal is not to cover any topic in depth, but rather touch on every activity that is part of the extreme programmer's daily life. At the end of the day, participants will not be extreme programmers, but they will be prepared to take their first steps.
The tutorial is primarily for programmers, although managers and customers will also benefit. Reading Extreme Programming Explained will prepare participants to get the most out of the day. Note, there will be no other prepared materials for the tutorial.
Expected audience:
Experienced developers, team leaders, software managers.
Required experience:
Object-Oriented software development experience.
Abstract:
Almost every expert in Object-Oriented Development stresses the
importance of iterative development. As you proceed with the
iterative development, you need to add function to the existing
code base. If you are really lucky that code base is structured
just right to support the new function while still preserving its
design integrity. Of course most of the time we are not lucky,
the code does not quite fit what we want to do. You could just
add the function on top of the code base. But soon this leads to
applying patch upon patch making your system more complex than it
needs to be. This complexity leads to bugs, and cripples your
productivity.
Refactoring is all about how you can avoid these problems by modifying your code in a controlled manner. Done well you can make far-reaching changes to an existing system quickly, and without introducing new bugs. You can even take a procedural body of code and refactor it into an effective object-oriented design. With refactoring as part of your development process you can keep your design clean, make it hard for bugs to breed and keeping your productivity high.
In this tutorial I'll show you an example of how a lump of poorly designed code can be put into good shape. In the process we'll see how refactoring works, demonstrate a handful of example refactorings, and discuss the key things you need to do to succeed.
Abstract |
Writing effective unit tests is a skill that takes practice to do well but is at the core of Extreme Programming. During this tutorial we will demonstrate real examples that address situations many programmers find hard to test. We will also show how test-driven development improves the quality of the code produced. Finally, we will consider the practical boundaries of effective unit testing. |
Benefits |
This tutorial will
|
Audience |
The session is intended for working programmers who are interested in writing effective unit tests. They should be familiar with Java and, preferably, standard libraries such as JDBC and servlets. The tutorial has a bias towards web development, but the techniques it covers are applicable elsewhere. |
Schedule |
This is a 3 hour tutorial.
|
Process |
After an introduction and welcome, we will ask every participant to contribute a card to our Box of Fears. These cards will describe something that they believe is difficult, or even impossible, to unit test. For our demonstrations, we will pair-program a working example, using the unit-testing techniques we wish to highlight. Following the canonical Beck/Cunningham tradition, we will pair with volunteers from the audience. Over the course of the tutorial, we will develop a simple end-to-end web application with persistent data. This will show three areas of unit-testing: a general introduction to test-driven development, event-driven with servlets, server libraries with jdbc. After each demonstration, we will summarise the techniques that we have just used. To give some variety, the introductory demonstration will be a file processing utility in Python. The pot-pourri section will cover topics such as testing generated server pages, testing within application servers, and writing test web clients. At the end of the tutorial, we will hold a discussion during which we will open the Box of Fears and consider whether we have addressed the issue on the cards. |
History |
This tutorial is based on the collective experience of the London XP community, as described in our paper in last year's conference, and on-going discussions over the year. We will be giving a shorter version of the tutorial at OT 2001 in Oxford and expect to run it at several companies in London. |
Steve Freeman |
I am a Principal Consultant at Big Blue Steel Tiger, where I develop e-commerce solutions. I am also responsible for helping to move Big Blue Steel Tiger towards Extreme Programming. Prior to this, I ran the largest XP project in the UK at Lombard Risk Systems. I have degrees in Statistics and Music, and a PhD in computer science from Cambridge University. I have written software for research labs, shrink-wrap and bespoke systems. |
Tim Mackinnon |
I am Head of Software Development at Connextra, a web technology company founded on XP principles. Before this I worked at Dashboards, a software consultancy, where I introduced the first XP project in the UK and was a founder member of www.xpdeveloper.com. I also worked for some years at OTI, developing shrink-wrap software in Smalltalk. I have a BCS from Carleton University. |
"Flexibility can be considered an option." - Nobel Prize in Economics lecture, 1997
In Extreme Programming Explained it is suggested that the economic value of flexible processes might be best analyzed by the application of a relatively new approach known as real options. This approach takes a perspective that the value of an asset lies not only in the amount of revenue explicitly generated, but also in the options it creates for flexible decision-making in the future. The tutorial covers traditional methods of valuation, option pricing theory, the application to real-world projects, and implications for management under uncertainty.
INTENDED AUDIENCE
All those interested in obtaining an overview of an emerging discipline for the economic and strategic analysis of information technology projects, particularly managers and project planners. The material is intended to be self-contained, with no requirements for previous experience in economic theory.
TUTORIAL OUTLINE
Introduction: Strategic Options in IT processes
Net Present Value and Valuation
Beyond NPV: Option Pricing Theory
Real Options and the Value of Flexible Processes
Implications for Management of Projects
John Favaro is an independent consultant based in Pisa, Italy. John was General Chair of the Sixth International Conference on Software Reuse in June 2000. He is European co-chair of the IEEE Technical Subcommittee on Reuse. Recently he has published articles on principles of strategy and valuation for IT investment, including "Value-Based Software Reuse Investment" in the special issue on reuse of Annals of Software Engineering 1998, the article that became the basis for the material on options in Extreme Programming Explained. He has degrees in Computer Science from Berkeley and Yale.
Required experience:
Attendees will be expected to understand Java and
have basic exposure to Design Patterns.
Aim:
While Software Patterns are undeniably powerful design aids, many programmers tend to
overuse them, prematurely introduce them, or implement them in unnecessarily
heavyweight ways. Refactoring to Patterns encourages a simpler, more disciplined
approach to using Patterns, based on the philosophy of eXtreme Programming. Using this
approach, programmers wait for the right time to refactor a Pattern into a system and do
so using the simplest possible Pattern implementations.
In this tutorial, we will examine 5 Design Patterns and 5 cases where we might refactor
these Patterns into Java code. During the process, we will investigate when it makes
sense to refactor to a Pattern, and what are simple implementations of each Pattern we
add.
Presenter:
Joshua Kerievsky is a consultant, programmer and founder of Industrial
Logic, Inc. He splits his time between mentoring and coaching XP projects
and designing and teaching Industrial Logic's workshops, including The eXtreme Programming
Workshop.
Creating good user stories is essential to a successful XP software project. User stories are so critical because they represent units of functionality in the project. These units are used for planning, testing, and most of all, showing progress in a project. As a result, they are vital to starting the project, keeping it alive, and demonstrating the intended functionality has been delivered.
We describe the principles that can used to guide the development of good user stories. We also discuss how user stories can be utilized to plan and test a project. We'll look at some innovative, yet practical techniques for getting the most out of your user stories on larger XP projects. Finally, we look at the requirements capturing techniques employed by other agile processes, Feature Driven Development and Crystal. These processes utilize features and use cases, respectively, instead of user stories to drive software development. We discuss the pros and cons of features and use cases in an agile process world.
This tutorial is interactive and will stress learning by working with actual user stories. We will write a few user stories and plan a project to illustrate some of new techniques. Finally, we will compare the effort required to write user stories against that of writing features or use cases.
This is a half day tutorial for intermediate to advanced XPers.
Content Outline:Granville Miller
TogetherSoft Inc.
Granville has 14 years of experience in the object-oriented community. He is a co-author of Advanced Use Case Modeling series (see www.advancedusecases.com). He has presented tutorials at conferences such as OOPSLA, Object Expo, and Smalltalk Solutions. He has been writing articles for industry and academic forums for nearly 10 years. Additionally, he was one of the original developers of IBM's VisualAge product. His "hands-on" approach to object-oriented programming has been the result of his work with companies that range from start-ups in the very early stages to the most established software giants.