Software Development for Small Teams: A RUP-Centric Approach

Summary

"I highly recommend this book for anyone who's ever tried to implement RUP on a small project. Pollice and company have demystified and effectively scaled the process while ensuring that its essence hasn't been compromised. A must-have for any RUPster's library!"
—Chris Soskin, Process Engineering Consultant, Toyota Motor Sales

Do you want to improve the process on your next project? Perhaps you'd like to combine the best practices from the Rational Unified Process (RUP) and from agile methodologies (such as Extreme Programming). If so, buy this book!

Software Development for Small Teams describes an entire software development project, from the initial customer contact through delivery of the software. Through a case study, it describes how one small, distributed team designed and applied a successful process. But this is not a perfect case study. The story includes what worked and what didn't, and describes how the team might change its process for the next project. The authors encourage you to assess their results and to use the lessons learned on your next project.

Key topics covered include:

Achieving a balance between people, process, and tools; recognizing that software development is primarily a human endeavor

Using RUP as an appropriate foundation for a small project; combining RUP and agile principles to create a workable process

Configuring a process that supports the project members, helping them work more effectively

Adjusting the process over the course of the project

Selecting tools to support a small, distributed team

Dealing effectively with your customer

Whether you're a project lead, a programmer, or another member of the development team, this book will show you how to tap the strengths of specific processes to dramatically increase the productivity of your team.

Table of Contents

Preface.

About This Book.

Who Should Read This Book?

Acknowledgments.

1. In The Beginning.

Meet the Team.

What's Next?

2. Using a Development Process on a Small Project.

What Is a Small Project?

What About Process on a Small Project?

Benefits of Using RUP on a Small Project.

Getting Started with RUP: The Project Leader.

Key Artifacts.

Level of Formality.

Techniques for Involving the Team.

Schedule Workshops.

Assign Mentors.

Staying on Track.

Summary.

3. People, Process, and Tools.

People.

Process.

Tools.

What Can Go Wrong?

Summary.

4. Getting Started: The Project Members Become a Team.

Coalescing Into a Team.

Forming the Team.

Dealing with Employer and Geographical Distribution.

Losing a Member.

Writing the Development Case.

Conventions Used in the Development Case.

Role Map.

Artifacts in Our Development Case.

Importance of the Development Case.

Reporting on our Progress.

Creating an Iteration Plan for Inception.

Summary.

5. Inception: We Start to Make Progress. e Vision: Setting Our Goals.

Discovering the Extent of the Project: What to Build and What Not to Build.

Who Are Our Stakeholders?

Identifying Stakeholders.

Writing a Brochure.

Specifying the Features.

Working With and Managing Requirements.

Defining the Initial Use Cases.

A Few Words About Diagrams.

Identifying Non-Functional Requirements.

Project Management.

Prioritizing Requirements.

Planning.

Risk.

Setting Up a Development Environment.

Language Tools.

Requirements Management Tools.

Configuration Management and Version Control Tools.

Testing Tools.

Collaboration Tools.

Tools in Other Environments.

Iteration evaluation.

This Sure Sounds Like Waterfall.

Summary.

6. Elaboration: We Create the Framework.

Elaboration Goals.

Toward Stability: Decreasing the Rate of Change.

Producing an Executable Architecture.

Adding Some Details to Requirements.

Creating Tests and Test Plans.

Creating the PSPTools Architecture.

Login: Not as Simple as We Thought.

Changes to the Tool Environment.

Forte to XDE—Goodbye to the GUI Builder.

New Uses for Groove.

Deferring Database Creation.

An Alternative to the Database.

Database Design.

Scope Management: Cut Early and Often.

What Do You Mean You Can't Install The Product?

Assessing Elaboration.

Reviewing the Executable Architecture.

Summary.

7. Technical Details for Elaboration.

Beginning Elaboration.

Which Java Platform?

What about the Database?

Other Development Tools.

Source Code Structure.

The PSPTools User Interface.

The User Interface Ripple Effect.

Our First UI.

Exploring the UI Code.

The PSPTools Database.

Unit Testing.

The Plan—Test-First Programming.

The Reality.

Tools and Techniques.

Summary.

8. Construction: We Build PSPTools.

Adjusting the Environment Again.

Version Control.

Defect Tracking.

Additional Requirements Management.

Construction Goals.

Construction Planning: the Project Heartbeat.

Discovering Our Own Rhythm.

Communicating by Release Notes.

Experimenting, Making Mistakes, and Arriving at Our Own Style of Planning.

Construction Begins.

The Fear Factor—An Example.

A Better Way to Deal with the Fear.

Another Short Tale.

Moving Forward in Construction.

Handling Database Changes.

Working Toward a Usable Product.

First Construction Increment.

Second Construction Increment.

Third Construction Increment.

Why Did Development Speed Up?

Beyond the Learning Curve.

Working with the Infrastructure.

Using Our Own Software.

Remaining Construction Increments.

Everyone Needs A Friend Sometimes: Programming in Pairs.

Testing During Construction.

Anticipating Change of Team Membership.

Summary.

9. Construction Details.

Fine-tuning the User Interface.

Dealing with Menus.

Adding Context Menus.

Displaying Time and Defect Details.

Adding User Preferences.

Finishing the Database.

Adding New Fields—Updating the Database Schema.

Allowing Single Quotes in Fields.

Testing.

Summary.

10. Transition: We Deliver PSPTools.

What is Transition?

Making the Transition to Transition.

Goals of Transition.

What about Requirements?

Avoiding Late Changes.

Aiming for a Short Transition Phase.

Example.

Defects are not Requirements.

Code Changes During Transition.

The Importance of Independent Testers.

The Brown Thumb.

Testing Your Own Software.

Packaging the Product.

User Documentation.

Training the Users.

Training a Larger Group of Customers.

Are We Done Yet?

Supporting Your Customers.

Preparing for the Next Version.

Summary.

11. Post-Mortem: How Will We Improve the Next Version?

What is a Post-Mortem?

Conducting a Post-Mortem Review.

Involve the Whole Team.

Provide an Agenda.

Establish Goals.

Provide Preparation Guidelines and Activities.

Employ a Facilitator.

Produce Action Items from the Review.

Act and Revisit Regularly.

Do Something Fun.

Our Post-Mortem Review.

What Went Well?

What Would You Change?

What Did You Learn?

Conclusions.

Tidying Up For The Next Project Team.

Refactoring.

The Final Diagrams.

Other Project Documentation.

The Changing Landscape.

Team Communication and Collaboration.

Changes in RUP.

IDE.

The Future of PSPTools.

Summary.

A. Overview of the Personal Software Process (PSP).

The Personal Software Process.

Goals and Focus.

Conclusion.

B. An Introduction to RUP.

The Gateway to RUP.

Phases<.dd>.

RUP Key Concepts.

Roles.

Activities.

RUP Milestones.

Goals of Inception.

Goals of Elaboration.

Goals of Construction.

Goals of Transition.

Summary.

C. Extreme Programming.

The Primary Values.

XP Practices.

Further Reading.
Index.