Software development for small teams : a RUP-centric approach
Author(s)
Bibliographic Information
Software development for small teams : a RUP-centric approach
（The Addison-Wesley object technology series / Grady Booch, Ivan Jacobson, James Rumbaugh）
Addison-Wesley, c2004
- alk. paper
Available at / 1 libraries
-
No Libraries matched.
- Remove all filters.
Note
Includes bibliographical references and index
Description and Table of Contents
Description
Many in the extreme and agile communities have long held the RationalUnified Process as being an antithesis approach to program development -citing it as being too process oriented, too rigid and structured, and overlyconcerned with documentation. This book is Rational's reaction to thatinaccurate perception. Using a project case study that is carried throughout thebook, the authors illustrate how agile techniques can be used effectively in aRUP environment. While not taking the extreme or agile communities to taskfor their expressed disdain for process, this book shows that process caneffectively accommodate design and development approaches which are notusually associated with the RUP. Software Engineering for Small Projectssuccessfully extends the appeal of the Rational Unified Process.
Table of Contents
Foreword.
Preface.
About This Book.
The PSP Tools Project.
How This Book Is Organized.
Who Should Read This Book?
Acknowledgments.
1. In the Beginning.
Meet the Team.
Gary.
Liz.
Chris.
Jas.
Russell.
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.
Key Artifacts.
Level of Formality.
Techniques for Involving the Team.
Schedule Workshops.
Assign Mentors.
Staying on Track.
For More Information.
Summary.
3. People, Process, and Tools.
People.
Harry and Gwen.
It's About Communication.
Team Composition.
Provide a Learning Environment.
Trust, the Glue for the Team.
Disagree Constructively.
The Power of Requests.
Recognize Achievement.
Process.
The Prime Directive.
Address Risk.
Don't Reinvent the Wheel.
Make Your Process Yours.
Use Your Brain.
Tools.
Building Your Own 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.
The 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 Nonfunctional 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 Phase Goals.
Toward Stability: Decreasing the Rate of Change.
Producing an Executable Architecture.
Adding Some Details to Requirements.
Creating Tests and Test Plans.
Don't Forget Exploratory Testing.
Unit Testing.
Creating the PSP Tools Architecture.
Login: Not as Simple as We Thought.
Changes to the Tool Environment.
Forte to XDE--Good-bye 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 the Elaboration Phase.
Reviewing the Executable Architecture.
Summary.
7. Elaboration Details.
Beginning the Elaboration Phase.
Which Java Platform?
What About the Database?
Other Development Tools.
Source Code Structure.
The PSP Tools User Interface.
The User Interface Ripple Effect.
Our First UI.
Exploring the UI Code.
The PSP Tools Database.
Unit Testing.
The Plan-Test-First Programming.
The Reality.
Tools and Techniques.
Summary.
8. Construction: We Build PSP Tools.
Adjusting the Environment Again.
Version Control.
Defect Tracking.
Additional Requirements Management.
Construction Phase Goals.
Construction Phase Planning: The Project Heartbeat.
Discovering Our Own Rhythm.
Communicating by Release Notes.
Experimenting, Making Mistakes, and Arriving at Our Own Style of Planning.
Implementation Accelerates.
The Fear Factor-An Example.
A Better Way to Deal with the Fear.
Another Short Tale.
Moving Forward in the Construction Phase.
Handling Database Changes.
Working Toward a Usable Product.
First Construction Phase Iteration.
Second Construction Phase Iteration.
Third Construction Phase Iteration.
Why Did Development Speed Up?
Beyond the Learning Curve.
Working with the Infrastructure.
Using Our Own Software.
Remaining Construction Phase Iterations.
Everyone Needs a Friend Sometimes: Programming in Pairs.
Testing During the Construction Phase.
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 PSP Tools.
What Is the Transition Phase?
Making the Transition to the Transition Phase.
Goals of the Transition Phase.
What About Requirements?
Avoiding Late Changes.
Aiming for a Short Transition Phase.
Example.
Defects Are Not Requirements.
Code Changes During the Transition Phase.
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?
Benefits of Conducting 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 PSP Tools.
Summary.
Appendix A. An Introduction to the Rational Unified Process (RUP).
The Gateway to RUP.
Phases.
RUP Key Concepts.
Roles.
Activities.
RUP Milestones.
Goals of Inception.
Goals of Elaboration.
Goals of Construction.
Goals of Transition.
Summary.
Appendix B. Overview of the Personal Software Process (PSP).
The Personal Software Process.
Goals and Focus.
Conclusion.
Appendix C. Introduction to eXtreme Programming (XP).
The Primary Values.
XP Practices.
Recommended Reading.
Index.
by "Nielsen BookData"