使用SCRUM进行敏捷.NET开发

需积分: 4 33 浏览量更新于2024-07-29 收藏 8.85MB PDF 举报

"Pro Agile .NET Development with SCRUM 电子书，PDF 格式，涵盖了敏捷开发、.NET 技术和 Scrum 框架的实践应用" 这本书深入介绍了敏捷开发的方法论，特别是针对 .NET 开发环境下的敏捷实践。作者通过一系列章节详细阐述了敏捷开发的艺术，以及如何在实际项目中运用 Scrum 方法。书中提到的 SuperJumper 是一个 2D OpenGLES 游戏的例子，用于展示敏捷开发过程中的各个环节。首先，书中的第一章"The Art of Agile Development"探讨了敏捷开发的核心理念，强调了快速响应变化、团队协作以及持续交付价值的重要性。这一章可能涵盖了敏捷宣言的四个价值观和十二条原则，以及敏捷开发相较于传统开发的优势。第三章"eXtreme Programming (XP)"讲解了极限编程的实践，包括持续集成、测试驱动开发(TDD)、结对编程和客户参与等关键实践。这些方法旨在提高代码质量，减少缺陷，并确保与客户需求保持一致。第四章"Sprint 0: Generating the Product Backlog"介绍了产品待办事项列表的创建，这是 Scrum 的重要组成部分，它定义了项目的范围和优先级。在这个阶段，团队会与利益相关者共同确定需求，并将它们转化为可工作的用户故事。第五章至第八章分别讲述了四个不同的迭代（Sprint）过程，从游戏的启动到游戏的发布。每个 Sprint 都包含了从设计、编码、测试到回顾的完整周期，展现了 Scrum 方法如何指导团队逐步构建和改进产品。第九章"Code Review"关注代码审查，这是保证代码质量和团队学习的重要步骤。通过同行评审，团队可以发现潜在问题，提高代码质量，并促进知识共享。第十章"What’s Ahead for You and Scrum?"展望了敏捷开发的未来，讨论了 Scrum 在不断变化的技术和业务环境中的适应性，以及团队如何持续改进和学习。书中的多个附录提供了关于特定工具和技术的入门指南，如 TDD 与 NUnit、BDD 与 SpecFlow、Mocking 与 Moq、产品待办事项管理工具 Pivotal Tracker、Web 测试工具 WatiN、版本控制工具 SVN 和持续集成工具 CruiseControl.NET。这本书是 .NET 开发者学习敏捷开发和 Scrum 实践的理想资源，它通过实际项目案例提供了丰富的实战经验，帮助读者理解和应用敏捷原则，提升软件开发效率和产品质量。

CHAPTER 1  THE ART OF AGILE DEVELOPMENT

W: Won’t have this time, but potentially later

All “must have” work is committed to being completed in the course of the project; all other work is

deemed a “nice to have” and is picked up only when the core requirements have been implemented.

Feature-Driven Development (FDD)

Feature-driven development (FDD) begins by creating a model of the domain under development. Once

this is completed, an iterative process of feature design and implementation begins. Features represent a

useful grouping of functionality to the customer. FDD is made up of the following five simple activities:

1. Develop the Domain Object Model

2. Create a feature list

3. Plan by feature

4. Design by feature

5. Build by feature

Lean Software Development

Lean software development comes from the Lean manufacturing principles that were derived mostly

from the production system created by Toyota. Lean focuses on customer value and the elimination of

waste. It achieves this by following these next seven principles:

1. Eliminate waste: Selects only the most valuable features for a customer.

2. Amplify learning: Learn by doing and testing things rather than documenting.

3. Decide as late as possible: Delay decisions in order to enable more facts to be

gathered and changes to take place.

4. Deliver as fast as possible: The sooner software is delivered, the sooner

feedback is received and incorporated into the next release, giving fast return

on investment to the business.

5. Empower the team: Make the team responsible and increase motivation by

including all members in the decision-making process.

6. Build integrity in: Re-factor regularly to keep code flexible and adaptable to

change.

7. See the whole: Ensure that domain knowledge is spread throughout the team

in order for problems to be identified at any level of the system.

Throughout this book we will be using the more popular agile methodologies, Scrum and XP, to

show you what it means to be agile.

CHAPTER 2  MANAGING AGILE PROJECTS WITH SCRUM

Figure 2-1. The Scrum process

The consistent sprint duration combined with the team being time boxed to work on features that

cannot be changed in that time frame, as well as short meetings and regular retrospectives, improve

development practice by generating a development rhythm. This rhythm enables the team to

concentrate on designing and developing high-quality software.

Now that you have an overview of what Scrum is, let’s dive deeper into the wonderful world of

Scrum.

Plan-Driven vs. Value-Driven Methods

When looking at the differences between the Waterfall method and the Agile method you need to look at

the core behind each method. One method is driven by the plan that was created at the beginning of the

project and the other method is driven by the value that you give the customer.

Waterfall Method (Plan Driven)

The waterfall method can be thought of as a plan-driven method of software development. In the past,

this method of development was used by many—not because it was the best way to develop software,

but because it was the only method known.

A project that used the waterfall method involved a large amount of risk, mainly because everything

was done at the beginning of the project. All the requirements gathering, and discovery and scope

definition was completed before the first line of code was ever written. Customers had to know up front

everything that they needed or wanted the system to do. At times customers did not know exactly what

they wanted, but yet, they had to define every last detail of their needs; and once they defined the details,

they could not change them—even if they later realized that their needs had changed.

This approach destined the project for failure before it even began. The entire process led to

problems that were hidden until toward the end of a project, simply because the customer had not

considered every little detail, and there was no way make changes as the need arose. Sometimes it was

too expensive to make a change. Scope creep was rampant in these kinds of projects; developers didn’t

understand the problem that the customer was trying to solve—and the customer didn’t either.

CHAPTER 2  MANAGING AGILE PROJECTS WITH SCRUM

Plan-driven development could be like a hoop jumping process: you started at discovery and once

you jumped through that hoop, it was on to the requirements-gathering hoop, and from there you went

on to the design hoop. You could not jump through one hoop until you had jumped through the

previous hoop, and once you were through a hoop it was near impossible to go back to a previous hoop

if the need arose. There was no allowance to do a little bit of everything and then pause to make sure you

were still on the right path. The waterfall process did not foster an environment where developers could

go to a customer and say, “I would like to show you what I am working on to make sure it is what you

want.”

Usually the big issues would surface toward the end of a project, which was rather late in the

process. This led to many development teams being behind on their projects. When teams got behind

on a project, they would just throw more bodies at the project, with the hope that the more people on

the project, the faster it would get done. That rarely happened. Most of the time the project would

remain behind schedule, so the team had to cut the scope, cut testing, or both.

Scrum Method (Value Driven)

Scrum is considered a value-driven method for software development. Scrum is a dramatic change over

the waterfall method for a number of reasons. Instead of first gathering all the requirements needed for

every feature of the project, completing all the designs based on these requirements, and then coding

the application based upon these up-front designs, Scrum looks at doing iterative, incremental

development.

Scrum is all about taking small passes at a problem and reassessing that problem after each pass.

Scrum is all about small:

• Small time blocks called sprints

• Small features

• Small teams

Small time blocks are how the team works on a solution for the customer. Each sprint can be looked

at as a mini waterfall project. This is because in every sprint you are doing everything you would

normally do in a waterfall project, except you are doing it on a smaller scale. In each sprint, you take a

feature and you gather requirements on that feature, you design that feature based on those

requirements, and you code and test that feature based on those designs. In Scrum, unlike waterfall, you

are not trying to do everything up front; you are doing everything you need to do when you need to do it.

The goal of each sprint is to deliver an increment of the final product—but an increment that is

potentially releasable.

So how can we do numerous waterfall projects in each sprint, when we could barely do one

waterfall project before? By doing these sprints against small features. Small features are pieces of a

project that try to solve a particular problem for the customer; they don’t attempt to create the whole

application. The massive features of the project are broken down into smaller chunks that can still

provide value to the customer and are able to be completed more quickly. As more and more of these

features are completed, the customer will start seeing the entire application coming into view.

All of this is done with a small team of developers, testers, and designers that are dedicated to

getting the project done. This team is cross functional in that every member knows how to do

everything. Each member may not be the best at everything, but everyone knows how to do everything

剩余380页未读，继续阅读

haifeng_su

粉丝: 0
资源: 3

使用SCRUM进行敏捷.NET开发

Pro Agile .NET Development with Scrum

Agile.Net_Obfuscator_6.4.0.1_Downloadly.ir.rar

Apress.Pro.Agile.NET.Development.with.Scrum

Agile product management with Scrum

Agile Project Management with Scrum

Agile Project Management with Scrum.pdf

Agile Project Managment With Scrum.pdf

敏捷编程管理Agile Project Management with Scrum

THE SCRUM PRIMER: An Introduction to Agile Project Management with Scrum

Agile .NET 6.3.0.5

最新资源