Extreme Software Engineering A Hands-On Approach: Steinberg, Daniel H.; Palmer, Daniel W.: 9780130473813: Book: Computers: eCampus.com

This hands-on software engineering volume fills the gap between the way users learn to program and the way software is written in professional practice with an interactive, project-oriented approach that includes guidelines for using XP methods for software engineering, tutorials on the core aspects of XP, and detailed descriptions of what to expect when applying XP to a development project. Using methodologies that are flexible enough to meet the changing needs of future clients, the book provides a detailed description of what happens in a typical cycle during an XP development effort and shows users what to do instead of telling them what to do. The volume provides an introduction to the Core XP practices, and details pair programming, understanding why we test first, the iteration, shaping the development process and core practices and working examples of core practices. For software engineers, developers, and programmers, and managers who want to learn about XP.

Acknowledgments

xxiii

Introduction---Previewing the Road Ahead

(1)

Software Engineering

(3)

Building Bridges

(1)

There Is No ``Software Physics'' Supporting Software Engineering

(1)

Tending Gardens

(1)

A ``Hands-on'' Software-Engineering Course

(2)

Course-Long Project

(1)

Outside Independent Client

(1)

Origin of the Hands-on Software-Engineering Course

(2)

Traditional Software Development

(1)

Organization of the Team

(1)

Extreme Programming

(4)

Learning XP

(1)

The Practices of Extreme Programming

(2)

Integrating XP and a Hands-on Software-Engineering Course

(3)

PART I THE SPIKE---GETTING UP TO SPEED

(52)

The Metaphor---Developing a Sense of Where We're Headed

(8)

Writing the Syllabus

(1)

First Things First

(1)

The Waterfall Method

(1)

Limitations of the Modified Waterfall

(4)

Unanswerable Questions

(1)

Building Estimates on No Data

(1)

The Life of the Project

(1)

What Happened?

(1)

Back to the Classroom

(1)

Software Engineering Approaches

(1)

Last Things First

(1)

Getting Started---Introducing the Core XP Practices

(10)

main ()

(1)

Spikes---A Quick Investigation

(1)

An XP Spike to Learn the Basic XP Practices

(4)

User Stories

(1)

Estimates

(1)

Living with Set Priorities

(1)

Pairing

(1)

Testing First

(1)

Continuous Design Improvement

(1)

Synergies

(1)

We Need to Do This before That

(1)

The Customer Makes the Business Decisions

(1)

Choosing an XP Spike

(2)

Pair Programming---Learning to Work Together

(16)

Roles in Pairing

(2)

The Driver

(1)

The Copilot

(1)

Good Things Happen in Pairs

(1)

A Tale of Two Pairings

(1)

Two Heads Are 1.7 Times Better than One

(1)

Benefits of Pair Programming

(4)

Real-Time Code Reviews

(1)

Avoiding Distractions

(1)

Managing for Two

(2)

Knowledge and Information Migration

(1)

Pairing in Practice---Dealing with Practical Issues

(4)

The Third Alternative

(1)

The Pair

(1)

Groups of Pairs

(1)

Learning by Watching and Doing

(1)

Reading Each Other's Signals

(1)

Giving Up the ``Wheel''

(1)

Font Size and Eyesight

(1)

Code Formatting

(1)

Revision Control

(1)

Mixing and Matching

(1)

Scheduling Time to Pair

(1)

A Final Word on Pairing

(1)

Pair Programming Exercises

(4)

First Test, Then Code---Understanding Why We Test First

(16)

How Can You Test First? There's Nothing to Test

(5)

Writing a Test Case

(1)

Passing the Test

(1)

What's an Alternative to Exhaustive Testing?

(2)

``Test First'' Really Does Mean ``Code Afterwards''

(1)

Developing a Test Suite

(1)

Automated Testing

(1)

Testing First Helps You Write Better Code

(4)

Testing First Forces Simplicity

(1)

Simplicity Drives the Design

(1)

Testing First Clarifies the Task at Hand

(1)

Testing First Frees You from On-the-Fly Editing

(1)

Test Suites Make Refactoring Possible

(1)

Testing First Makes Sense

(1)

Test Suite Maintenance

(1)

Fixing Broken Test Cases

(1)

Adding Missing Tests

(1)

Test Suites Considered Helpful---To the Team's Frame of Mind

(1)

The Psychological Benefits of Green

(1)

The Psychological Benefits of Red

(1)

Testing First Exercises

(4)

PART II THE ITERATION---SHAPING THE DEVELOPMENT PROCESS

(60)

The Client---Meeting Another Team Member

(14)

The Client's Job

(1)

How Is This Client Different from ``Real'' Clients?

(4)

Investment

(1)

Commitment

(1)

Relationship

(1)

Pace and Decisions

(1)

The Planning Game

(8)

Meeting to Determine User Stories

(1)

Analysis and Estimation

(1)

Determining Your Workload

(1)

Reevaluating and Prioritizing the User Stories

(1)

Choosing and Estimating Tasks

(1)

Dealing with Disappointment

(1)

The End of the First Iteration

(1)

Rinse and Repeat

(2)

The Plans---Beginning an Iteration

(10)

Kicking Off Every Iteration

(2)

Taking Stock of Where You Are

(1)

Breaking Down Tasks

(3)

Working Plans

(1)

Communication Plans

(1)

Integration Plans

(1)

The First Iteration

(4)

Installing Software

(1)

First Estimates

(1)

Coding Conventions

(2)

The Values, Principles, and Practices---Living the Iteration

(12)

The Core of the Iteration

(2)

Problems That Arise

(5)

Do We Really Have to Pair Program?

(1)

No All Nighters

(2)

The Simplest Thing Isn't Obvious

(1)

Hey, That's My Code

(1)

The Larger View of XP

100

(5)

Values

101

(2)

Principles

103

(2)

Acceptance Tests---Determining that a Story is Completed

105

(12)

Aren't We Testing Already?

106

(1)

Running Acceptance Tests

107

(1)

Understanding the Tests

108

(3)

Writing the Tests

111

(2)

Automating the Tests

113

(3)

Using a Custom Framework

113

(2)

The Fit Framework

115

(1)

Exercise

116

(1)

Evaluation and Regrouping---Wrapping Up an Iteration

117

(10)

Finishing Up Each Iteration

117

(1)

Run Acceptance Tests

118

(1)

Assess What Was Completed

119

(1)

Discuss Problems That Came Up

119

(1)

Budget for the Next Iteration

120

(1)

Estimate User Stories

121

(1)

Deliver to the Client

122

(1)

Plan with the Client

123

(1)

Completing the Last Iteration

123

(1)

Include the Wrap Up in Your Estimates

124

(1)

Assess Where You Are

124

(1)

Prepare the Final Presentation

124

(1)

Prepare the Final Installation

124

(3)

PART III CORE PRACTICES---WORKING EXAMPLES OF CORE PRACTICES

127

(118)

Test First---Learning a New Way of Life

129

(22)

Overview of Testing First

129

(2)

The Rules of Life

131

(1)

Setting Up JUnit

132

(2)

Setting Up the Infrastructure

132

(1)

Running a Suite

133

(1)

Creating Your First Test

134

(4)

Extending TestCase

134

(1)

Where Do Tests Come From?

135

(1)

Writing Your Test

135

(1)

Getting It to Compile

136

(1)

Getting It to Pass

136

(1)

Look Around for Refactoring

137

(1)

Writing More Tests

138

(3)

Checking for Changes in Live Cells

138

(2)

Check for Changes in Dead Cells

140

(1)

What You Don't Have

141

(1)

Allowing Cells to Change

141

(3)

The Test Cases

142

(1)

Refactoring

143

(1)

Testing GUIs

144

(6)

A Second Extension to TestCase

144

(1)

Tests for Cell's GUI

145

(2)

Testing Communication from Cell to CellPanel

147

(1)

Testing Communication from CellPanel to Cell

148

(2)

A Look Back

150

(1)

Exercises

150

(1)

User Stories---Exploring with the Customer

151

(14)

Before the First Meeting

152

(1)

Writing Your First User Story

153

(2)

Taking Stock of Artifacts

153

(1)

Write a User Story

154

(1)

Story Gathering

155

(2)

Find a Starting Point

155

(1)

Following a Path

155

(1)

Going Too Far

156

(1)

Getting Back on Track

157

(3)

Exploring Time Slots

157

(2)

Courses and Sections

159

(1)

Wrapping Up with the Client

160

(4)

Stopping the Client

161

(1)

Ordering the Stories

161

(1)

Preparing the Client for Reality

161

(3)

Client Variations

164

(1)

The Planning Game---Negotiating the Future

165

(18)

The Beginning User Stories

168

(2)

Refining the User Stories

170

(4)

Selecting User Stories for the First Iteration

174

(3)

The Client Provides a Basic Ordering of Stories

174

(1)

The Developers Provide Rough Estimates of the Stories

175

(1)

The Client Chooses the Current Iteration

176

(1)

A Closer Look at the Estimates

177

(4)

The Developers Break the Stories into Tasks

177

(2)

The Developers Estimate the Tasks

179

(2)

Reality Check

181

(2)

Moving from One Iteration to Another

181

(2)

Refactoring---Sharpening Your Knife

183

(14)

Example Application the Tetris Game

184

(1)

Duplicated Code

185

(4)

Example: In a Single Method

185

(3)

Example: In Two Classes

188

(1)

Almost Duplicated Code

189

(3)

Example: In Different Methods of One Class

190

(1)

Example: In Two Classes

190

(2)

What's in a Name

192

(2)

Splitting Long Methods

194

(2)

Final Thoughts

196

(1)

Customer Written Tests---Automating the Acceptance Process

197

(34)

The Fit Framework

198

(4)

Writing Acceptance Tests as HTML Tables

198

(1)

Supporting the HTML Tables with Fixtures

199

(1)

Writing the Code to Pass the Tests

200

(1)

Running Acceptance Tests with Fit

200

(1)

Exploring Fit

201

(1)

From User Stories to Acceptance Tests

202

(2)

Our First Example User Story

202

(1)

Initial Acceptance Tests for the Case Discount Story

202

(2)

Benefits of Having Acceptance Tests

204

(1)

Formalizing the Acceptance Tests

204

(15)

Mapping to the Fixture

204

(3)

Running the Tests

207

(1)

Creating a Stub Fixture

208

(3)

Writing the Production Code

211

(2)

Tying the Fixture to the Production Code

213

(1)

Passing More Acceptance Tests

213

(3)

The Client and the Acceptance Tests

216

(3)

Testing GUIs

219

(7)

Designing the Acceptance Tests

220

(1)

Stubbing Out a Fixture for the Tests

221

(1)

Problems Passing the Acceptance Tests

222

(2)

The Revised Fixture and Production Code

224

(2)

Running All of the Tests

226

(5)

The All Files Fixture

226

(1)

Results of Running the All Files Fixture

227

(1)

Next Steps

228

(3)

Development Mechanics---Organizing Your Project

231

(14)

Packages

231

(4)

A Two Class Example

232

(1)

Adding a Main Class

233

(1)

A Sample Hierarchy

234

(1)

Preparing Your Files for a Release

235

(2)

Separating Source and Class Files

236

(1)

Jar-ing Up the Results

236

(1)

Packaging Your Unit Test Files

237

(3)

The Tests

237

(2)

Separating the Test Files

239

(1)

JavaDocs

240

(2)

The Various Builds

242

(3)

Integrating Code

242

(1)

Distribution Checklist

243

(1)

Automating the Build

244

(1)

APPENDIX A EXPERIENCE IN THE TRENCHES---SHARING USER STORIES

245

(8)

APPENDIX B FOR PROFESSIONALS---CUSTOMIZING THE COURSE

253

(10)

Training Workshop

253

(4)

The Compressed Spike

254

(1)

A Three-day Project

255

(1)

A Postmortem Discussion

256

(1)

Self-Paced Self-Taught Practicum

257

(6)

Learning with a Partner

257

(2)

An Individualized Approach

259

(4)

References

263

(2)

Index

265


	Buy Textbooks Sell Textbooks College Apparel Shop by School Virtual Bookstores	Order Status Shipping Rates Return Policy Marketplace Info F.A.S.T.	Contact Us Privacy Policy Legal Notices Site Security Employment	Help Desk eCampus Blog Affiliate Program Bulk Orders College Marketing

Need Help? eService@ecampus.com Copyright© 1999-2008
.