Software Development for Small Teams: A RUP-Centric Approach
Gary Pollice, Liz Augustine, Chris Lowe, Jas Madhur
- 出版商: Addison Wesley
- 出版日期: 2003-12-19
- 售價: $1,410
- 貴賓價: 9.5 折 $1,340
- 語言: 英文
- 頁數: 304
- 裝訂: Paperback
- ISBN: 0321199502
- ISBN-13: 9780321199508
"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
About This Book.
Who Should Read This Book?
1. In The Beginning.
Meet the Team.
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.
Level of Formality.
Techniques for Involving the Team.
Staying on Track.
3. People, Process, and Tools.
What Can Go Wrong?
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.
Artifacts in Our Development Case.
Importance of the Development Case.
Reporting on our Progress.
Creating an Iteration Plan for Inception.
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?
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.
Setting Up a Development Environment.
Requirements Management Tools.
Configuration Management and Version Control Tools.
Tools in Other Environments.
This Sure Sounds Like Waterfall.
6. Elaboration: We Create the Framework.
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.
Scope Management: Cut Early and Often.
What Do You Mean You Can't Install The Product?
Reviewing the Executable Architecture.
7. Technical Details for 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.
The Plan—Test-First Programming.
Tools and Techniques.
8. Construction: We Build PSPTools.
Adjusting the Environment Again.
Additional Requirements Management.
Construction Planning: the Project Heartbeat.
Discovering Our Own Rhythm.
Communicating by Release Notes.
Experimenting, Making Mistakes, and Arriving at Our Own Style of Planning.
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.
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.
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.
Defects are not Requirements.
Code Changes During Transition.
The Importance of Independent Testers.
The Brown Thumb.
Testing Your Own Software.
Packaging the Product.
Training the Users.
Training a Larger Group of Customers.
Are We Done Yet?
Supporting Your Customers.
Preparing for the Next Version.
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.
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?
Tidying Up For The Next Project Team.
The Final Diagrams.
Other Project Documentation.
The Changing Landscape.
Team Communication and Collaboration.
Changes in RUP.
The Future of PSPTools.
A. Overview of the Personal Software Process (PSP).
The Personal Software Process.
Goals and Focus.
B. An Introduction to RUP.
The Gateway to RUP.
RUP Key Concepts.
Goals of Inception.
Goals of Elaboration.
Goals of Construction.
Goals of Transition.
C. Extreme Programming.
The Primary Values.