﻿<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:trackback="http://madskills.com/public/xml/rss/module/trackback/" xmlns:wfw="http://wellformedweb.org/CommentAPI/" xmlns:slash="http://purl.org/rss/1.0/modules/slash/"><channel><title>BlogJava-陈朋奕和谢仍明的博客-文章分类-XP极限编程体验</title><link>http://www2.blogjava.net/chenpengyi/category/7587.html</link><description>MySQL资料，Java技术，管理思想，博弈论，Ajax，XP极限编程，物流知识</description><language>zh-cn</language><lastBuildDate>Tue, 27 Feb 2007 20:24:20 GMT</lastBuildDate><pubDate>Tue, 27 Feb 2007 20:24:20 GMT</pubDate><ttl>60</ttl><item><title>大型项目的XP(极限编程)（来自：UMLCHINA ）</title><link>http://www.blogjava.net/chenpengyi/articles/31552.html</link><dc:creator>陈朋奕</dc:creator><author>陈朋奕</author><pubDate>Sun, 19 Feb 2006 13:12:00 GMT</pubDate><guid>http://www.blogjava.net/chenpengyi/articles/31552.html</guid><wfw:comment>http://www.blogjava.net/chenpengyi/comments/31552.html</wfw:comment><comments>http://www.blogjava.net/chenpengyi/articles/31552.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/chenpengyi/comments/commentRss/31552.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/chenpengyi/services/trackbacks/31552.html</trackback:ping><description><![CDATA[<FONT color=#000000 size=2>作者：Amr Elssamadisy 著，simaetin 译<BR>本文选自：UMLCHINA&nbsp;&nbsp;<BR>2002年05月13日&nbsp;</FONT> 
<P><FONT color=#000000><FONT size=2>我们在ThoughtWorks这样的大型项目中应用XP方法的时间超过了15个月。这个项目开始于三年前，那时它有大量的需求文档和几个独立的功能小组。从2000年1月起，我们决定应用XP，虽然当时我们已经知道XP并不适用于大型项目。那时，我们需要向客户提交功能演示，并要通过提交一个工作子集而不仅仅是原型来赢得他们的信心（我们在团队中有超过25名开发人员和大约15名分析员）。但我们并未准备好功能，各个组都使用自己的代码框架，一个完整的应用无从谈起。简短地说，就是客户想要看到点什么，但我们还没有真正的功能。应该说开发的第一迭代期是成功的：我们给客户提交了一个真正的应用子集。成功的首要原因是我们让来自Asset, AR 和GUI组从事不同工作的开发者融合在一起。当然，其间也有"成长的烦恼"：在分析员和开发者之间发生某些个人冲突，但我们成功跨越了这些障碍。那时一切都很美好：我们以飞快的速度成功地提交了功能演示，但随着时间的流逝和项目的继续，有些事情却不如我们所愿。这就是这篇文章要讲述的内容：我们真正的收获在"蜜月"期后，关于我们如何在一年半中管理一个50人的项目开发并及时完成阶段性的提交（尽管有时并不成功），关于我们经历的痛苦，我们后续的工作，我们最终学到的以及作为改进要用到下一个项目中的经验。<BR><BR>首先，我们给出我们开始的状况：15个月前我们是如何应用XP的，然后展示我们现在的XP应用情况。也就是说，下面将讨论我们改变技术的原因。这是一个自然选择的过程，它剔除了许多不好的想法，或把它们改造成更有效的方法，使之更适于大型项目。最后我们将总结并给出在大型项目中使用XP的谨慎建议。<BR><BR>大型项目中XP的元素<BR><BR>好吧，让我们来进入正题。我们开发和分析的队伍由大约35名开发人员、15名分析人员和10名QA组成。开发人员依赖分析人员作为项目的客户。尽管有实际的客户，分析人员还是要协同工作以便有选择地做出客户决策。下表演示了[1]所讨论的XP基本元素并简要介绍了这些方面如何应用到项目的各个阶段。我们用这个表来分析我们团队自然选择的实践，以及书本上的XP如何应用到一个超过50人的大型项目中。<BR><BR><CCID_NOBR></FONT></FONT></P>
<TABLE style="BORDER-COLLAPSE: collapse" borderColor=#111111 cellSpacing=0 cellPadding=2 width=550 border=1>
<TBODY>
<TR align=middle>
<TD><FONT color=#000000 size=2>　</FONT></TD>
<TD><FONT color=#000000 size=2>计划</FONT></TD>
<TD><FONT color=#000000 size=2>提交周期</FONT></TD>
<TD><FONT color=#000000 size=2>比喻</FONT></TD>
<TD><FONT color=#000000 size=2>设计的简单性</FONT></TD>
<TD><FONT color=#000000 size=2>测试</FONT></TD>
<TD><FONT color=#000000 size=2>重构</FONT></TD></TR>
<TR align=middle>
<TD><FONT color=#000000 size=2>1/2000</FONT></TD>
<TD><FONT color=#000000 size=2>大跨度的迭代计划会议。开发和分析组的全部成员整天在一起讨论新的故事卡片和预估。大多数开发者签入（sign up）新的功能。</FONT></TD>
<TD><FONT color=#000000 size=2>1个月</FONT></TD>
<TD><FONT color=#000000 size=2>无</FONT></TD>
<TD><FONT color=#000000 size=2>转变已有的代码基准。已有的代码依然复杂，但新的代码要尽可能简单。这个阶段包括抛弃老的代码和重写那些"今后可能会被用到"的功能代码。</FONT></TD>
<TD><FONT color=#000000 size=2>单元测试开始于一些新的代码。推动建立一个大的测试基准。QA做所有的功能测试并有权留弃故事卡片。</FONT></TD>
<TD><FONT color=#000000 size=2>对于旧有代码，如有必要就进行重构。</FONT></TD></TR>
<TR align=middle>
<TD><FONT color=#000000 size=2>7/2000</FONT></TD>
<TD><FONT color=#000000 size=2>基本同1/2000，但确实感觉十分低效。多数与会者没能很好地参与。拖沓的讨论，50人的会议是无法忍受的。</FONT></TD>
<TD><FONT color=#000000 size=2>1个月</FONT></TD>
<TD><FONT color=#000000 size=2>无</FONT></TD>
<TD><FONT color=#000000 size=2>以尽可能简单的原则继续设计。完成对已有设计的重构。完成代码会审，旨在全体范围中讨论新设计以便整个团队了解代码和设计的发展趋势。</FONT></TD>
<TD><FONT color=#000000 size=2>更好的单元测试覆盖更大的范围，尽管没有完全覆盖。代码功能测试帮助覆盖测试范围。</FONT></TD>
<TD><FONT color=#000000 size=2>多数开发人员埋头于新功能的开发，很少会去做重构。代码基准在迭代期末向QA组提交卡片时变得糟糕起来。</FONT></TD></TR>
<TR align=middle>
<TD><FONT color=#000000 size=2>1/2001</FONT></TD>
<TD><FONT color=#000000 size=2>希望能尽快做出每个迭代期间的计划-我们的办法是在正式会议前以小组为单位进行更多的准备工作。</FONT></TD>
<TD><FONT color=#000000 size=2>2 周</FONT></TD>
<TD><FONT color=#000000 size=2>无</FONT></TD>
<TD><FONT color=#000000 size=2>多数的设计基于已有的设计：保留标准，代码会审逐渐停止，因为新的设计和重构尚未完成。</FONT></TD>
<TD><FONT color=#000000 size=2>试图去掉代码功能测试而代之以屏幕搜刮(Screen Scraper)，若失败就回到代码功能测试 。加入新的单元测试但仍然没有全部覆盖。QA组开始结合界面测试使用自动功能测试。</FONT></TD>
<TD><FONT color=#000000 size=2>重构开始更频繁，因为部分代码开始变得凌乱不堪。需要清理的原因主要是实现简单和迭代期限使得代码在没有重要重构的情况下增长。</FONT></TD></TR>
<TR align=middle>
<TD><FONT color=#000000 size=2>6/2001</FONT></TD>
<TD><FONT color=#000000 size=2>举行一些讨论卡片或相关卡片组的会议，参加者包括对这些功能感兴趣或有经验的开发者和负责这些卡片的分析人员。</FONT></TD>
<TD><FONT color=#000000 size=2>2 周</FONT></TD>
<TD><FONT color=#000000 size=2>无</FONT></TD>
<TD><FONT color=#000000 size=2>队伍中的大多数人及整个QA组准备提交1.0版本给客户。代码的基准分离以便加入没有测试的新功能。对单元测试有更多的依赖。</FONT></TD>
<TD><FONT color=#000000 size=2>尽管仍有遗漏，测试范围已经基本稳定。QA组不再测试新功能，因为焦点是1.0版本的提交。</FONT></TD>
<TD><FONT color=#000000 size=2>在发布版上做的重构很少，而在继续开发的版本上，开发人员会很尽责地进行重构，特别是在年初被迫做了更大更痛苦的重构以后.</FONT></TD></TR></TBODY></TABLE></CCID_NOBR><BR><BR><CCID_NOBR>
<TABLE style="BORDER-COLLAPSE: collapse" borderColor=#111111 cellSpacing=0 cellPadding=2 width=550 border=1>
<TBODY>
<TR align=middle>
<TD><FONT color=#000000 size=2>　</FONT></TD>
<TD><FONT color=#000000 size=2>结对编程</FONT></TD>
<TD><FONT color=#000000 size=2>集体所有</FONT></TD>
<TD><FONT color=#000000 size=2>持续集成</FONT></TD>
<TD><FONT color=#000000 size=2>40小时周</FONT></TD>
<TD><FONT color=#000000 size=2>在场客户</FONT></TD>
<TD><FONT color=#000000 size=2>代码规范</FONT></TD></TR>
<TR align=middle>
<TD><FONT color=#000000 size=2>1/2000</FONT></TD>
<TD><FONT color=#000000 size=2>由于我们决定采用XP，整个团队读了[1]。每个人都做了尝试，多数人被吸引。</FONT></TD>
<TD><FONT color=#000000 size=2>由于最初阶段的分组是面向功能，因此此时我们并未意识到集体所有 (collective ownership) ，也没有意识到代码的保护。</FONT></TD>
<TD><FONT color=#000000 size=2>从第一迭代期开始，进行在线集成，参见［2］</FONT></TD>
<TD><FONT color=#000000 size=2>这是一个概念工作时间：因为我们希望客户在场。于是我们会花另外的时间来满足最后期限。</FONT></TD>
<TD><FONT color=#000000 size=2>事务分析人员是在场的客户，他们15人一组。真正的客户是不在的，由分析人员同他们沟通。 基本上是JAVA的一般语法。</FONT></TD></TR>
<TR align=middle>
<TD><FONT color=#000000 size=2>7/2000</FONT></TD>
<TD><FONT color=#000000 size=2>结对编程依旧盛行：开发者对新功能进行结对编程，但改错和维护工作由单个人来做。也有一些开发者停止了结对编程。</FONT></TD>
<TD><FONT color=#000000 size=2>当开发者越来越多地接触</FONT><A href="http://jizhuwo.com/System/index.html" target=_blank><FONT color=#000000 size=2>系统</FONT></A><FONT color=#000000 size=2>不同的部分的时候，代码的所有者逐渐显现出来。成员间通过闲谈，代码互审和短小的站立会议（Stand up meeting）进行很好的沟通。</FONT></TD>
<TD><FONT color=#000000 size=2>代码功能测试加入构造过程。</FONT></TD>
<TD><FONT color=#000000 size=2>为了通过故事卡片，在每个迭代期的最后工作时间达到50至60小时。</FONT></TD>
<TD><FONT color=#000000 size=2>同上</FONT></TD>
<TD><FONT color=#000000 size=2>两周一次的代码互审给开发人员一个机会讨论不同子</FONT><A href="http://jizhuwo.com/System/index.html" target=_blank><FONT color=#000000 size=2>系统</FONT></A><FONT color=#000000 size=2>的实现方式。我们可以接受某些子</FONT><A href="http://jizhuwo.com/System/index.html" target=_blank><FONT color=#000000 size=2>系统</FONT></A><FONT color=#000000 size=2>代码的非正式方式。</FONT></TD></TR>
<TR align=middle>
<TD><FONT color=#000000 size=2>1/2001</FONT></TD>
<TD><FONT color=#000000 size=2>结对编程更少了，因为这一阶段编码更直接，而有些人在进行重构。</FONT></TD>
<TD><FONT color=#000000 size=2>因为效率低，站立会议被弃用，但代码的所有显现得更加清晰。开发人员开始专职负责</FONT><A href="http://jizhuwo.com/System/index.html" target=_blank><FONT color=#000000 size=2>系统</FONT></A><FONT color=#000000 size=2>的某部分。</FONT></TD>
<TD><FONT color=#000000 size=2>稳定_同上。</FONT></TD>
<TD><FONT color=#000000 size=2>以2周为迭代期，开发人员的工作时间更接近于40小时…</FONT></TD>
<TD><FONT color=#000000 size=2>同上</FONT></TD>
<TD><FONT color=#000000 size=2>代码互审逐渐减少，设计及编码规范趋于饱和。</FONT></TD></TR>
<TR align=middle>
<TD><FONT color=#000000 size=2>6/2001</FONT></TD>
<TD><FONT color=#000000 size=2>定下了规则：所有新功能要应用结对编程，而改错和维护则由一人完成。</FONT></TD>
<TD><FONT color=#000000 size=2>随着专业化分工的继续,不同的开发小组人员拥有不同部分代码的知识，于是我们将使他们在接下来相应模块的设计中起更活跃的作用，但代码仍是集体共有。</FONT></TD>
<TD><FONT color=#000000 size=2>稳定同上。</FONT></TD>
<TD><FONT color=#000000 size=2>同上</FONT></TD>
<TD><FONT color=#000000 size=2>同上</FONT></TD>
<TD><FONT color=#000000 size=2>同上</FONT></TD></TR></TBODY></TABLE></CCID_NOBR><BR><BR><CCID_NOBR><FONT color=#000000><FONT size=2><STRONG>结对编程</STRONG></CCID_NOBR> <BR><BR>首先我们说说结对编程的体会。多数情况下，我们在某个迭代期间有两个开发人员同时为一个故事卡片（或几个迭代期的相关卡片）工作。在大型项目中开发人员需要投入更多的关注，因为开始新领域的编码的热身时间是不容忽视的。开发人员间良好的沟通和周期性的计划会议让每个人都具有谁在做什么的整体概念。这使得经典教科书中开发者甲找到开发者乙要求共同解决问题的结对编程方式成为可能。<BR><BR>结对编程当然很好，但并非任何时侯都适用。最通常的情况是，在改错和维护时开发人员并不愿结对，并且这种情况下许多眼睛盯着调试代码也确实没什么好处。再有就是迭代期间的重复工作，这种情况下，问题的解决方案已经确定，不必再结对了。<BR><BR>还有，开发人员有不同的个性：有些人需要间歇性的结对编程，而有些人更加出色，结对编程会妨碍他们才能的发挥而最终成为他们的负担。<BR><BR><CCID_NOBR><STRONG>单元测试和集成构造</STRONG></CCID_NOBR> <BR><BR>单元测试和集成构造绝对是必要的，这意味着如果我们没有测试，我们就不能提交任何代码。当应用</FONT></FONT><A href="http://jizhuwo.com/Dev/index.html" target=_blank><FONT color=#000000 size=2>程序</FONT></A><FONT color=#000000 size=2>变得越来越大时，没有测试我们就不能加入任何新功能或进行重构。我们现在在新代码进库时会有集成构造和测试。关于这些构造及测试的细节，负责人员会及时放在内部网页上，这样每个开发人员都能知道当前的构造状态，事务分析员和QA能拿到最近构造的信息来测试新的功能。<BR><BR><CCID_NOBR><STRONG>组内所有和信息共享</STRONG></CCID_NOBR> <BR><BR>对于这样一个大型的项目，为了防止被分为孤立的部分而使整个</FONT><A href="http://jizhuwo.com/System/index.html" target=_blank><FONT color=#000000 size=2>系统</FONT></A><FONT color=#000000 size=2>做出不适当的假设，信息的发布和不同部分的代码轮作非常重要。沟通是必需的（但我们无法强迫一个沉默的人开口）于是我们试图在每两周一次的短会上给每个人发言的机会，以使沉默寡言的人能说出他们的要求。而最终我们取消了这样的会议，因为大多数开发人员认为这种把每件事都蜻蜓点水地提一下的会议只是浪费时间。这也是这个团队的优点之一??我们总能象一个共同体般地工作，如同结对编程一样地合作。<BR><BR>开始，我们采用了轮作的方法，也就是每个人对每件事都作一点，这使得我们在后来快到截止期限的时候都在从事己经了解的事情。但对于一段复杂的代码，要做到这一点，时间投入非常巨大。最好采用折衷的办法：也<BR><BR>就是在项目时间紧的时候只作每个人熟悉的工作，而在其它时候，比如改错、研究或正在做一项熟悉的工作时，可以同时做一件不熟悉的事。我们现在的原则是，开发人员在几个迭代周期中连续做一些相关的卡片，同时逐渐地转向</FONT><A href="http://jizhuwo.com/System/index.html" target=_blank><FONT color=#000000 size=2>系统</FONT></A><FONT color=#000000 size=2>的其它部分。在同一个迭代期内签入几个不同卡片的做法己经不再用了。<BR><BR>代码确实会越变越糟。是因为我们的项目有些大吗？还是因为许多做代码的人都是新手（是指这个功能领域中的新手，而非编程新手）？答案可能是二者皆有吧。但有时我们不接触代码，很难开始</FONT><A href="http://jizhuwo.com/System/index.html" target=_blank><FONT color=#000000 size=2>系统</FONT></A><FONT color=#000000 size=2>的其它部分，因此定期清理代码是必须的。这样引出我们下一个论题：重构。<BR><BR><CCID_NOBR><STRONG>重构</STRONG></CCID_NOBR> <BR><BR>在应用XP的大型项目中，为了消除代码的不一致性，重构是绝对必要的。即便对于那些对项目的应用领域很熟悉的人，也会面对重构的巨大工作量望而却步。对于项目经理来说，必须认识到重构需要另行分配时间。我们做到了这一点，我们留出了时间来重构代码的主要部分。<BR><BR><CCID_NOBR><STRONG>短迭代周期</STRONG></CCID_NOBR> <BR><BR>迭代期及其期限是必须的，但长度一直是个问题。过去我们采用长迭代周期（如一个月），而每到月末就会很紧张并伴随着一些不良代码的加入，并且不可避免地在估计上出现问题。我们不得不接受一些未做的卡片（这对开发人员来说非常困难，并且难以满足既定的期限）。<BR><BR><CCID_NOBR><STRONG>总结</STRONG></CCID_NOBR> <BR><BR>下面把18个月中我们在这个50人项目的经验和教训列出如下：<BR><BR>1) 在每个迭代期开始时进行迭代计划会议。每日客户和开发人员讨论最近的故事卡片并评估它们，在每天的讨论结束后重新分组并演示这些评价和发现，然后让开发人员签入。这可以让整个项目组知道项目的当前情况而不用让每个人都卷入马拉松式的会议。<BR><BR>2) 使提交版本周期尽可能短：我们是两周一次，但在必要的时候也可以使提交跨多个迭代周期。允许在多个迭代周期签入卡片，但要以每个周期为单位进行进度的监控。<BR><BR>3) 进行尽可能多的单元测试，这是不言而喻的。应当有一个自动进行功能测试的软件包以保证测试的覆盖范围。但是QA组是不可替代的（无论开发人员写过多少测试</FONT><A href="http://jizhuwo.com/Dev/index.html" target=_blank><FONT color=#000000 size=2>程序</FONT></A><FONT color=#000000 size=2>），因为我们对</FONT><A href="http://jizhuwo.com/System/index.html" target=_blank><FONT color=#000000 size=2>系统</FONT></A><FONT color=#000000 size=2>怎样工作总是存在偏见。<BR><BR>4) 简单的设计能帮助我们连续向客户提供可工作的版本。频繁的设计会议对于加入大量新功能时是很有用的，而午餐是一个召集整个项目组的好时候。这可以避免在</FONT><A href="http://jizhuwo.com/System/index.html" target=_blank><FONT color=#000000 size=2>系统</FONT></A><FONT color=#000000 size=2>的不同部分同时存在不兼容的解决方案。<BR><BR>5) 重构是能够做到简单设计的唯一方法。设计的重构与代码的重构同等重要。尽管不进行重构而采用打补丁的解决方法往往是有吸引力的，但是如果一个</FONT><A href="http://jizhuwo.com/System/index.html" target=_blank><FONT color=#000000 size=2>系统</FONT></A><FONT color=#000000 size=2>的补丁太多，那就意味着今后它将进行更大的重构。<BR><BR>6) 在加入新功能时，要坚定不移地贯彻结对编程，而在改错和做重复性工作时停止，因为问题已经在结对时解决了。<BR><BR>7) 集体所有和沟通密不可分。团队必须有一种有效的沟通方式。也许不仅仅是非正式的讨论，有时定期的10到15分钟的发布会是很好的方式。<BR><BR>8) 在大型项目中，一些人要扮演客户的角色，为大量开发人员产生足够的工作。这和领域知识密切相关。<BR><BR>9) 编码标准是十分非正式的，这不会损害你的进度。更重要的是一种通过演示的沟通。代码不是文档的全部，开发人员需要看到全貌，这是代码不能提供的。<BR><BR>也有一些规则我们没有实行：<BR><BR>1) 两周一次的站立会议是低效的。可以选择每月一次的迭代团队通气会来替代。<BR><BR>2) 迭代计划会议没有必要让全部人员参与。更好的方式是按更小的组进行研讨，而在每天下班前用30到45分钟对卡片进行讨论。<BR><BR>3) 一个月的迭代期太长，不利于产生高质量的代码。2周一次的迭代周期更容易跟踪并使估计更准确。<BR><BR>4) 上一点在大代码量时并不合适，特别是重构大规模</FONT><A href="http://jizhuwo.com/System/index.html" target=_blank><FONT color=#000000 size=2>系统</FONT></A><FONT color=#000000 size=2>时。这时一张卡片会影响到多个迭代期。<BR><BR>5) 比喻（Metaphor）对于大型</FONT><A href="http://jizhuwo.com/System/index.html" target=_blank><FONT color=#000000 size=2>系统</FONT></A><FONT color=#000000 size=2>是不适合的。<BR><BR>6) 每周40小时我们来说不成问题，40小时是最少的情况，超时工作并没有给我们带来不利的影响。要重申的是，我们不是100%的实行结对编程。<BR><BR>这就是XP，或者说我们的XP版本，在我们小组所做的工作。我们经历了按时提交大型复杂应用的过程，也为每个开发人员提供了应对此类项目的宝贵经验。<BR><BR><CCID_NOBR><STRONG>参考书目</STRONG></CCID_NOBR> <BR><BR>1. Beck, K. Extreme Programming Explained: Embrace Change. Addison-Wesley, 1999; ISBN201-61641-6<BR><BR>2. Fowler, M. and Foemmel, M.; Continuous Integration</FONT><img src ="http://www.blogjava.net/chenpengyi/aggbug/31552.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/chenpengyi/" target="_blank">陈朋奕</a> 2006-02-19 21:12 <a href="http://www.blogjava.net/chenpengyi/articles/31552.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>何时应该使用极限编程（来自：UML工程组织）</title><link>http://www.blogjava.net/chenpengyi/articles/31549.html</link><dc:creator>陈朋奕</dc:creator><author>陈朋奕</author><pubDate>Sun, 19 Feb 2006 13:11:00 GMT</pubDate><guid>http://www.blogjava.net/chenpengyi/articles/31549.html</guid><wfw:comment>http://www.blogjava.net/chenpengyi/comments/31549.html</wfw:comment><comments>http://www.blogjava.net/chenpengyi/articles/31549.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/chenpengyi/comments/commentRss/31549.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/chenpengyi/services/trackbacks/31549.html</trackback:ping><description><![CDATA[<FONT color=#000000 size=2>NetReptile推荐&nbsp;[2005-7-17]<BR>出处：UML工程组织<BR>作者：不详<BR>&nbsp;<BR><BR></FONT>
<P><FONT color=#000000 size=2>极限编程（XP）适用于需求经常发生变化的项目。你的客户对</FONT><A href="http://jizhuwo.com/System/index.html" target=_blank><FONT color=#000000 size=2>系统</FONT></A><FONT color=#000000 size=2>应该做什么可能没有一个固定的想法；一个</FONT><A href="http://jizhuwo.com/System/index.html" target=_blank><FONT color=#000000 size=2>系统</FONT></A><FONT color=#000000 size=2>每隔几个月其功能就要求进行一定的改变。大多数软件项目的需求都处于这样的动态变化之中。与其它的方法相比，XP能够更好地适应这种情况。<BR><BR><IMG height=4 alt=" " src="" width=45 align=bottom border=0>XP适用于高风险的项目。&nbsp;如果客户需要一个新的</FONT><A href="http://jizhuwo.com/System/index.html" target=_blank><FONT color=#000000 size=2>系统</FONT></A><FONT color=#000000 size=2>，而且要求在某天前完成，这里的风险就比较高；如果你的开发组没有做过类似的</FONT><A href="http://jizhuwo.com/System/index.html" target=_blank><FONT color=#000000 size=2>系统</FONT></A><FONT color=#000000 size=2>，风险就更高了；如果该</FONT><A href="http://jizhuwo.com/System/index.html" target=_blank><FONT color=#000000 size=2>系统</FONT></A><FONT color=#000000 size=2>对整个软件业来说都是一个新的挑战，那这风险就可想而知。使用XP可以降低风险和增加成功的可能性。<BR><BR><IMG height=4 alt=" " src="" width=45 align=bottom border=0> XP适用于小规模的项目组，一般在2到10人之间。使用XP不需要拥有博士头衔的开发人员，一般的开发人员就可以。但不能在一个大型的项目组中采用XP。我们注意到，对于一个需求动态变化和高风险的项目而言，一小组XP开发人员要比大的开发组更加有效。 </FONT>
<P><FONT color=#000000 size=2><IMG height=4 alt=" " src="" width=45 align=bottom border=0>XP对项目组的组成人员有要求。组内不仅包括开发人员，还包括经理和客户，所有人员肩并肩地战斗在一起。软件开发中问题的讨论，项目范围和进度的协商，以及功能测试的创建仅靠开发人员是不够的。<BR><BR><IMG height=4 alt=" " src="" width=45 align=bottom border=0>XP对可测试性有要求。你必须建立自动的单元测试和功能测试。虽然在某些情况下这个要求不能满足，但事实上你会惊讶地看到通过某种方式仍然可以达到这个要求。比如可以通过修改</FONT><A href="http://jizhuwo.com/System/index.html" target=_blank><FONT color=#000000 size=2>系统</FONT></A><FONT color=#000000 size=2>的设计以使之已于测试。记住，只要你愿意就可以找到一种测试的方式。<BR><BR><IMG height=4 alt=" " src="" width=45 align=bottom border=0> XP对生产力也有要求。从已有的报告中，在相同条件下，所有采取XP的项目组都无一例外地比其它项目组的生产力高。但这从来不是XP的目的。XP的真正目的在于按时交付客户需要的软件。如果这对于你的项目而言很重要，你就可以尝试一下XP。</FONT></P><img src ="http://www.blogjava.net/chenpengyi/aggbug/31549.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/chenpengyi/" target="_blank">陈朋奕</a> 2006-02-19 21:11 <a href="http://www.blogjava.net/chenpengyi/articles/31549.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>配对编程（来自：ZDNet）</title><link>http://www.blogjava.net/chenpengyi/articles/31548.html</link><dc:creator>陈朋奕</dc:creator><author>陈朋奕</author><pubDate>Sun, 19 Feb 2006 13:08:00 GMT</pubDate><guid>http://www.blogjava.net/chenpengyi/articles/31548.html</guid><wfw:comment>http://www.blogjava.net/chenpengyi/comments/31548.html</wfw:comment><comments>http://www.blogjava.net/chenpengyi/articles/31548.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/chenpengyi/comments/commentRss/31548.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/chenpengyi/services/trackbacks/31548.html</trackback:ping><description><![CDATA[<FONT size=2><FONT color=#000000>NetReptile推荐&nbsp;[2005-7-17]<BR>出处：ZDNet<BR>作者：Steve Hayes<BR></FONT><FONT color=#000000>&nbsp;</FONT><BR><BR></FONT>
<P><FONT color=#000000></FONT>
<P><FONT color=#000000 size=2>配对编程是极限编程里争议最大的做法之一——支持者和反对者对此的反应都相当强烈。那么什么是配对编程？为什么人们对此的反应这么大？</FONT></P>
<P><FONT color=#000000 size=2>Laurie Williams将配对编程（pair programming）描述为“一种编程风格，它由两个</FONT><A href="http://jizhuwo.com/Dev/index.html" target=_blank><FONT color=#000000 size=2>程序</FONT></A><FONT color=#000000 size=2>员并排在一台计算机上工作，连续协作完成同一个设计、算法、代码或者测试”。从上面的描述我们可以清楚地看出，配对编程的含义不仅仅是编程本身的键入，我个人认为“配对开发（pair development）”应该是对这种活动的更好描述。</FONT></P>
<P><FONT color=#000000 size=2>配对编程不是一个人简单地看着另一个在做什么——在卓有成效的配对工作里，这两个合作伙伴常常工作在不同抽象层次，一个人关注的是为实现眼前目标而编写的代码的细节，而另一个人考虑的是更大的前景和下一步要做的事情，这两个人的角色频繁进行更换。这是一项高强度的、严密的，且常常令人疲劳的活动，但是能够创造出经过深思熟虑的高质量代码。</FONT></P>
<P><FONT color=#000000 size=2>反对配对编程的大多数强烈反应都源于配对编程对社会上业已形成的软件开发习惯的挑战。</FONT></P>
<P><FONT color=#000000 size=2>对编程的传统看法是在隔离上花一大段时间，在此期间</FONT><A href="http://jizhuwo.com/Dev/index.html" target=_blank><FONT color=#000000 size=2>程序</FONT></A><FONT color=#000000 size=2>员进入一个“流程”，只与计算机和他们自己的思考模式进行交互。这样做的结果就是，编程往往更受性格内向的人的欢迎，因为这样的人喜欢将社交活动减到最少，而对那些外向的人却吸引力不大，因为他们更希望时时刻刻进行合作。</FONT></P>
<P><FONT color=#000000 size=2>当然这些都是一般的想法，但是总有不愿意与其他人肩并肩工作</FONT><A href="http://jizhuwo.com/Dev/index.html" target=_blank><FONT color=#000000 size=2>程序</FONT></A><FONT color=#000000 size=2>员，对他们工作的满意度肯定会受到像配对编程这样的事的影响，了解这种情况是非常重要的。</FONT></P>
<P><FONT color=#000000 size=2>对配对编程也有反应不太强烈的反对，一般都是与让两个人在一台机器上工作所花费的时间肯定要比他们各自独立工作然后合并工作成果所需要的时间多一倍的思想有关。</FONT></P>
<P><FONT color=#000000 size=2>如果将软件开发的因素限定为编程的时候我们能够输入有多快，这肯定是对的，但是根据Kent Beck的观察，如果情况真的如此的话，我们给每个</FONT><A href="http://jizhuwo.com/Dev/index.html" target=_blank><FONT color=#000000 size=2>程序</FONT></A><FONT color=#000000 size=2>员一份Mavis Beacon（盲打教学软件）就行了。</FONT></P>
<P><FONT color=#000000 size=2>我自己不会盲打，我也从来都没有在面试别人的时候问过他们的打字速度，所以打字速度是我们的主要关注因素的想法是值得怀疑的。然而，软件开发是一项智力活动，它能够从清楚的表达和思想的合作发展中受益，而配对编程在这两个方面都有所帮助。</FONT></P>
<P><FONT color=#000000 size=2>另外一个误解是，配对编程成功与否，应该最终由产出的软件的质量来确定。当两个人合作的时候，至少有三种结果：</FONT></P>
<UL type=disc>
<LI><FONT color=#000000 size=2>软件 </FONT>
<LI><FONT color=#000000 size=2>对应用</FONT><A href="http://jizhuwo.com/Dev/index.html" target=_blank><FONT color=#000000 size=2>程序</FONT></A><FONT color=#000000 size=2>的共同理解（业务域、设计和实现） </FONT>
<LI><FONT color=#000000 size=2>技能的转移 </FONT></LI></UL>
<P><FONT color=#000000 size=2>这些变化的比例取决于配对的平衡和动态，但是上述所有三者都会在某种程度上表现出来。当一个经验丰富的</FONT><A href="http://jizhuwo.com/Dev/index.html" target=_blank><FONT color=#000000 size=2>程序</FONT></A><FONT color=#000000 size=2>员与一个新手配对的时候，配对产生的软件可能不会被那个有经验的</FONT><A href="http://jizhuwo.com/Dev/index.html" target=_blank><FONT color=#000000 size=2>程序</FONT></A><FONT color=#000000 size=2>员单独工作产生的软件更多，但是这个新手肯定会学到很多关于这个应用</FONT><A href="http://jizhuwo.com/Dev/index.html" target=_blank><FONT color=#000000 size=2>程序</FONT></A><FONT color=#000000 size=2>的知识以及关于编程的基本知识。</FONT></P>
<P><FONT color=#000000 size=2>将这一情形与两人单独工作相比较——我们可能得到更多的软件（尽管我们可能希望更加注意新手编写的软件的质量），但是我们却没有实现知识或者技能的转移。如果我们让这两个人在同一个小组里，配对编程就是两个人度过共同时光的理想方法。</FONT></P>
<P><FONT color=#000000 size=2>而另一方面，两个有经验的人可能会发现配对编程里没有什么技能的转移，但是让他们在不同的抽象层次解决同一个问题会让他们更快地找到解决方案，而且错误更少。</FONT></P>
<P><FONT color=#000000 size=2>配对编程的另一个目标是尽可能广泛地传播应用</FONT><A href="http://jizhuwo.com/Dev/index.html" target=_blank><FONT color=#000000 size=2>程序</FONT></A><FONT color=#000000 size=2>设计和实现的知识。</FONT></P>
<P><FONT color=#000000 size=2>这是通过配对轮换实现的，这样小组配对的每个人都可以通过一段时间和其他所有人进行配对，而且应用</FONT><A href="http://jizhuwo.com/Dev/index.html" target=_blank><FONT color=#000000 size=2>程序</FONT></A><FONT color=#000000 size=2>的特定部分都会由尽可能多的人来解决。在这种环境里，糟糕的代码不会存在太久，因为它被暴露在很多双眼睛下（这就与开发人员代码开发背后的一个原理相似），而且当设计周期到来的时候，小组就会从所有人的贡献里受益，而不需要仅仅依赖某个熟悉应用</FONT><A href="http://jizhuwo.com/Dev/index.html" target=_blank><FONT color=#000000 size=2>程序</FONT></A><FONT color=#000000 size=2>特定部分的个人。</FONT></P>
<P><FONT color=#000000 size=2>配对编程还有其他多种好处：</FONT></P>
<UL type=disc>
<LI><FONT color=#000000 size=2>直接的、连续的代码回顾 </FONT>
<LI><FONT color=#000000 size=2>与别人工作会增加责任和纪律性。在有人盯着的时候去偷懒要困难得多！ </FONT>
<LI><FONT color=#000000 size=2>两个</FONT><A href="http://jizhuwo.com/Dev/index.html" target=_blank><FONT color=#000000 size=2>程序</FONT></A><FONT color=#000000 size=2>员具有相同的缺点和盲点的可能性很小，所以我们会获得一个强大的解决方案。 </FONT>
<LI><FONT color=#000000 size=2>如果走进死胡同，配对浪费的时间要少得多，因为其中一个人不可避免地会厌烦，从而希望寻求帮助。 </FONT></LI></UL>
<P><FONT color=#000000 size=2>在定期配对轮换的情况下，上面列表里的最后两项尤其现实。当然，做得看起来像配对编程的方式有很多，但是却无法实现，或者破坏了这些优势。</FONT></P>
<P><FONT color=#000000 size=2>如果不进行配对轮换，那么你所获得只会是编程的小圈子，知识和技术的转移也只会是最小。有些公司将配对编程用作是消灭个人空间（每两个</FONT><A href="http://jizhuwo.com/Dev/index.html" target=_blank><FONT color=#000000 size=2>程序</FONT></A><FONT color=#000000 size=2>员只需要一张桌子和一台计算机，不是吗？）的理由，这只会忽视</FONT><A href="http://jizhuwo.com/Dev/index.html" target=_blank><FONT color=#000000 size=2>程序</FONT></A><FONT color=#000000 size=2>员的人类需求。</FONT></P>
<P><FONT color=#000000 size=2>希望让</FONT><A href="http://jizhuwo.com/Dev/index.html" target=_blank><FONT color=#000000 size=2>程序</FONT></A><FONT color=#000000 size=2>员一天八个小时都配对工作是不现实的——配对的持续交互带来了精确和清晰的结果，但是这一过程也是耗费精力的，而且（一个人）总是会有开发以外的任务要完成。</FONT></P>
<P><FONT color=#000000 size=2>实践经验告诉我们，配对编程是提高软件质量和减少开发时间的有效方法，但是它并不适用于所有的</FONT><A href="http://jizhuwo.com/Dev/index.html" target=_blank><FONT color=#000000 size=2>程序</FONT></A><FONT color=#000000 size=2>员，它需要一种经过仔细思考的方式实现才能有效。</FONT></P>
<P><FONT color=#000000><FONT size=2><I>Steve Hayes</I><I>是Internet Business Systems</I><I>（IBS</I><I>）公司的软件开发经理。IBS</I><I>公司为金融服务行业提供敏捷开发方法咨询和开发服务，以及浏览器托管解决方案。</I></FONT></FONT></P><img src ="http://www.blogjava.net/chenpengyi/aggbug/31548.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/chenpengyi/" target="_blank">陈朋奕</a> 2006-02-19 21:08 <a href="http://www.blogjava.net/chenpengyi/articles/31548.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>XP设计原则（来自：xpchina:BrokenDoor）</title><link>http://www.blogjava.net/chenpengyi/articles/31547.html</link><dc:creator>陈朋奕</dc:creator><author>陈朋奕</author><pubDate>Sun, 19 Feb 2006 13:07:00 GMT</pubDate><guid>http://www.blogjava.net/chenpengyi/articles/31547.html</guid><wfw:comment>http://www.blogjava.net/chenpengyi/comments/31547.html</wfw:comment><comments>http://www.blogjava.net/chenpengyi/articles/31547.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/chenpengyi/comments/commentRss/31547.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/chenpengyi/services/trackbacks/31547.html</trackback:ping><description><![CDATA[<FONT color=#000000><FONT size=2><STRONG>1 简单是关键&nbsp;<BR></STRONG>简单的设计总是花较少的时间完成复杂的任务。因此记住要总是做有可能完成的最简单的事情。如果你发现一个事情很复杂，用简单的事情替换它。与其在复杂的代码上消耗更多的时间，还不如用简单的代码替换，这样更快，而且更省事。尽可能使事情简单化，在执行计划期间，尽可能不增加新的功能。要记住保持简单的设计是长期坚持的工作。&nbsp;<BR><BR></FONT></FONT><FONT color=#000000 size=2><STRONG>2 选择</STRONG></FONT><A href="http://jizhuwo.com/System/index.html" target=_blank><FONT color=#000000 size=2><STRONG>系统</STRONG></FONT></A><FONT color=#000000 size=2><STRONG>比喻&nbsp;<BR></STRONG></FONT><FONT color=#000000 size=2>选择</FONT><A href="http://jizhuwo.com/System/index.html" target=_blank><FONT color=#000000 size=2>系统</FONT></A><FONT color=#000000 size=2>比喻是为了通过对类和方法的一致命名，为团队提供一致的画面。你的对象名称对于</FONT><A href="http://jizhuwo.com/System/index.html" target=_blank><FONT color=#000000 size=2>系统</FONT></A><FONT color=#000000 size=2>整体设计的理解和代码重用是非常重要的。如果能取一个名字，使它容易猜出来，并且还是正确的，那么你就是一个能节约时间的人。选择一个涉及广泛的对象命名的方法而没有详细描述，很难获取对于</FONT><A href="http://jizhuwo.com/System/index.html" target=_blank><FONT color=#000000 size=2>系统</FONT></A><FONT color=#000000 size=2>的认识。&nbsp;<BR>例如克莱斯勒汽车公司薪水支付</FONT><A href="http://jizhuwo.com/System/index.html" target=_blank><FONT color=#000000 size=2>系统</FONT></A><FONT color=#000000 size=2>象生产线那样被建造了。福特汽车销售</FONT><A href="http://jizhuwo.com/System/index.html" target=_blank><FONT color=#000000 size=2>系统</FONT></A><FONT color=#000000 size=2>象材料清单那样被构造了。使用基于你本身领域的美丽的比喻，使它为人所知。但是，除非它相当简单，别选美丽的比喻。&nbsp;<BR><BR></FONT><FONT color=#000000><FONT size=2><B>3 CRC 卡片&nbsp;<BR></B>使用CRC（Class,Responsibilities,Collaboration）卡片来作为团队的设计。CRC卡的最大价值在于允许人们从思考过程模式中脱离出来，更充分的专注于对象技术。CRC卡允许整个项目组对设计做出贡献。参与</FONT></FONT><A href="http://jizhuwo.com/System/index.html" target=_blank><FONT color=#000000 size=2>系统</FONT></A><FONT color=#000000 size=2>设计的人越多，能够收集到的好主意也就越多。&nbsp;<BR>个别的CRC卡被用来描述对象。对象的类写在卡的最上边、责任在左边下边编成表，每个责任的右边是协作的类列表。因为以前CRC会议是大家全力参与的，通常只需要很少的有类名的卡片，实际上没有写出完整的卡片，所以，我们说“要写”。这个例子显示咖啡制造商问题的一部分。&nbsp;<BR>CRC会议继续进行，一些人模拟</FONT><A href="http://jizhuwo.com/System/index.html" target=_blank><FONT color=#000000 size=2>系统</FONT></A><FONT color=#000000 size=2>和对象交流，把消息传给其他的对象。通过一步步处理弱点，问题很容易地被解决。设计选择可以通过做建议的模拟实验迅速地做出决定。&nbsp;<BR>如果你发现很多人在讲话并且移动卡片，立即简单的限制站着的人数，把卡片移到下一人。当一个人座下的时候，其它的人可以站起来。自由讨论会议这项工作，常常发生的情况就像当艰难的问题最终被解答的时候，开发组变得吵闹一样。&nbsp;<BR>CRC卡受到的最大的批评之一是缺乏有记录的设计。CRC卡使设计看上去显而易见，所以这通常不需要。应该要求永久性的记录，每一个类一张卡，每个卡作为文档详细记录和保留。一旦预想已经建立和运行，在一段时间内，设计被人记住了。&nbsp;<BR><BR></FONT><FONT color=#000000><FONT size=2><B>4 道钉解决方案&nbsp;<BR></B>为了对技术或设计的难题的做出解答，产生道钉解决方案。道钉解决方案是一个探究潜在解决方案的非常简单的</FONT></FONT><A href="http://jizhuwo.com/Dev/index.html" target=_blank><FONT color=#000000 size=2>程序</FONT></A><FONT color=#000000 size=2>。构造一个</FONT><A href="http://jizhuwo.com/System/index.html" target=_blank><FONT color=#000000 size=2>系统</FONT></A><FONT color=#000000 size=2>，仅仅专注于检查出现的问题，忽略所有其它的方面大部分的道钉不会保持的足够好，所以，要打算扔掉它。使用道钉的目标是减少技术性问题的风险，或者，增加用户故事&nbsp;<BR>评估的可靠性。当技术性的困难阻碍</FONT><A href="http://jizhuwo.com/System/index.html" target=_blank><FONT color=#000000 size=2>系统</FONT></A><FONT color=#000000 size=2>开发的时候，在这个难题上配备一对开发者，给上一星期或两个星期的时间以减少潜在的危险。&nbsp;<BR><BR></FONT><FONT color=#000000><FONT size=2><B>5 不要过早地增加功能&nbsp;<BR></B>保持</FONT></FONT><A href="http://jizhuwo.com/System/index.html" target=_blank><FONT color=#000000 size=2>系统</FONT></A><FONT color=#000000 size=2>的整洁，把你猜想的额外的素材以后加入。只有10%的额外素材得到使用，所以你在浪费90%的时间。因为我们明白怎样增加，或者我们想使</FONT><A href="http://jizhuwo.com/System/index.html" target=_blank><FONT color=#000000 size=2>系统</FONT></A><FONT color=#000000 size=2>变得更好，所以我们都被诱惑到现在增加功能而不是以后。现在增加功能，似乎更快。但是，我们需要常常提醒自己：实际上我们不需要它。额外的功能将总是使我们开发变慢，而且浪费我们的资源。把眼光放到将来的需求和额外的适应性上。只关注于今天的进度。&nbsp;<BR><BR></FONT><FONT color=#000000><FONT size=2><B>6 及时地重新构造&nbsp;<BR></B>在软件变的不适用以后很长时间，我们的算机</FONT></FONT><A href="http://jizhuwo.com/Dev/index.html" target=_blank><FONT color=#000000 size=2>程序</FONT></A><FONT color=#000000 size=2>员仍然保持设计不变。我们继续使用和重用很长时间没有维护的代码，因为在某种方式下还能继续工作，我们害怕修改它。但是，这样去做真的值得吗？极端编程（XP）认为不是这样。当我们除掉冗余，删除未使用的功能，更新陈旧设计的时候，我们进行&nbsp;<BR>重新构造（refactor）。贯穿整个项目生命周期的重构工作节约了时间，保证了质量。&nbsp;<BR>为了保持设计的简单，避免不必要的混乱和复杂，及时重构。保持代码的简洁、明了，以便它更容易理解、修改和扩展。确认每件事情都被表示一次，并且只一次。结果，花更少的时间产生更好的</FONT><A href="http://jizhuwo.com/System/index.html" target=_blank><FONT color=#000000 size=2>系统</FONT></A><FONT color=#000000 size=2>。&nbsp;<BR>重构有几个要点。首先，很难，因为你必须能够放开你想象中的完美的设计，接受你通过重构偶然发现的设计。你必须认识到你想象的设计只是好向导方向，实际上马上会变得陈旧。&nbsp;<BR>为了吃到大量的树叶，毛虫是一个完美的设计，但是，它不能找到配偶，它在计划找到它的同类以前，必须把自己变成一只蝴蝶。放弃你认为</FONT><A href="http://jizhuwo.com/System/index.html" target=_blank><FONT color=#000000 size=2>系统</FONT></A><FONT color=#000000 size=2>应该是什么或不是什么的想法，试着留心在你面前出现的新的设计。 <BR></FONT><img src ="http://www.blogjava.net/chenpengyi/aggbug/31547.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/chenpengyi/" target="_blank">陈朋奕</a> 2006-02-19 21:07 <a href="http://www.blogjava.net/chenpengyi/articles/31547.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>XP实践整理(来自：XPChina BrokenDoor )</title><link>http://www.blogjava.net/chenpengyi/articles/31546.html</link><dc:creator>陈朋奕</dc:creator><author>陈朋奕</author><pubDate>Sun, 19 Feb 2006 13:04:00 GMT</pubDate><guid>http://www.blogjava.net/chenpengyi/articles/31546.html</guid><wfw:comment>http://www.blogjava.net/chenpengyi/comments/31546.html</wfw:comment><comments>http://www.blogjava.net/chenpengyi/articles/31546.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/chenpengyi/comments/commentRss/31546.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/chenpengyi/services/trackbacks/31546.html</trackback:ping><description><![CDATA[<FONT color=#000000><FONT size=2><STRONG>1 为什么是XP<BR><BR></STRONG>让我们来考虑一个传统的途径：用户组和开发组协商让一个分析员设计一个项目。在几周和几个月中，分析员和用户每天会面几个小时。分析员生产出一套文档，可能还包括象一个可视描述和用例之类。用户和项目经理（也可能是编程团队）回顾这些文档并且协商出一个发行版。</FONT></FONT><A href="http://jizhuwo.com/Dev/index.html" target=_blank><FONT color=#000000 size=2>程序</FONT></A><FONT color=#000000 size=2>员使用规范在几个月之后成长出一个</FONT><A href="http://jizhuwo.com/System/index.html" target=_blank><FONT color=#000000 size=2>系统</FONT></A><FONT color=#000000 size=2>，或多或少的实现了原来的想法。在结束的时候这通常是一个闭呼叫</FONT><A href="http://jizhuwo.com/System/index.html" target=_blank><FONT color=#000000 size=2>系统</FONT></A><FONT color=#000000 size=2>，当人们发现他们所遗漏的并意识到自从文档被写好以来什么都已经改变了。最后，用户加入进来作一个用户接受测试然后</FONT><A href="http://jizhuwo.com/System/index.html" target=_blank><FONT color=#000000 size=2>系统</FONT></A><FONT color=#000000 size=2>被发布。&nbsp;<BR><BR>通常整个过程所花费的时间比任何人所期望的都长，会遗漏一些特征，并且质量并不是用户想要的。更有甚着，文档也不再随日期更新。&nbsp;<BR><BR>问题总结：&nbsp;<BR>不能完全理解用户需求（用户自己也经常不清楚自己需要什么）&nbsp;<BR>用户的要求不断变化&nbsp;<BR>技术更新速度很快&nbsp;<BR>开发人员缺乏成功经验&nbsp;<BR>开发小组不稳定&nbsp;<BR>没有完整的测试设计&nbsp;<BR><BR><BR>--------------------------------------------------------------------------------<BR><BR><BR></FONT><FONT color=#000000><FONT size=2><B>2 XP简介<BR></B><BR>XP全名Extreme Programming ，一种轻量级，灵活的方法。&nbsp;<BR>XP 规定了一组核心价值和方法，可以让软件开发人员发挥他们的专长：编写代码。XP 消除了大多数重量型过程的不必要产物，通过减慢开发速度、耗费开发人员的精力（例如干特图、状态报告，以及多卷需求文档）从目标偏离。&nbsp;<BR>在XP中，在用户vs</FONT></FONT><A href="http://jizhuwo.com/Dev/index.html" target=_blank><FONT color=#000000 size=2>程序</FONT></A><FONT color=#000000 size=2>员的角色中有一个基本的分隔。用户拥有*what you get*，而</FONT><A href="http://jizhuwo.com/Dev/index.html" target=_blank><FONT color=#000000 size=2>程序</FONT></A><FONT color=#000000 size=2>员拥有*what it costs*。这显示了谁能作出什么决定。 即用户做企业决策，</FONT><A href="http://jizhuwo.com/Dev/index.html" target=_blank><FONT color=#000000 size=2>程序</FONT></A><FONT color=#000000 size=2>员做技术决策。&nbsp;<BR><BR>2.1 用户决定：&nbsp;<BR><BR>范围：什么</FONT><A href="http://jizhuwo.com/System/index.html" target=_blank><FONT color=#000000 size=2>系统</FONT></A><FONT color=#000000 size=2>是必须作的。&nbsp;<BR><BR>优先级：对于企业价值什么是最重要的。&nbsp;<BR><BR>发行的组合：什么是必须在发行版中的，一定是有用的？&nbsp;<BR><BR>发行的日期：什么时候需要发行？&nbsp;<BR><BR>2.2 </FONT><A href="http://jizhuwo.com/Dev/index.html" target=_blank><FONT color=#000000 size=2>程序</FONT></A><FONT color=#000000 size=2>员决定：&nbsp;<BR><BR>评估添加一个特征的时间 ，以及每个特征的风险&nbsp;<BR><BR>使用各种技术选项所花费的成本 ：</FONT><A href="http://jizhuwo.com/Dev/index.html" target=_blank><FONT color=#000000 size=2>程序</FONT></A><FONT color=#000000 size=2>员解释</FONT><A href="http://jizhuwo.com/Dev/index.html" target=_blank><FONT color=#000000 size=2>程序</FONT></A><FONT color=#000000 size=2>选择的结果，但是用户作决定&nbsp;<BR><BR>过程：小组怎么样工作，团队怎么组织&nbsp;<BR><BR>细节时间表：在一个迭代中特征先开发风险最大的那一个特征可以减轻风险&nbsp;<BR><BR>2.3 XP 的核心价值为：&nbsp;<BR><BR>交流。 项目的问题往往可以追溯到某人在某个时刻没有和其他人一起商量某些重要问题上。使用 XP，不交流是不可能的事。&nbsp;<BR><BR><BR>简单。 XP 建议您总是尽可能围绕过程和编写代码做最简单的事情。按照 Beck 的说法，“XP 就是打赌。它打赌今天最好做些简单的事...而不是做更复杂但可能永远也不会用到的事。”&nbsp;<BR><BR><BR>反馈。 更早和经常来自客户、团队和实际最终用户的具体反馈意见为您提供更多的机会来调整您的力量。反馈可以让您把握住正确的方向，少走弯路。&nbsp;<BR><BR><BR>勇气。 勇气存在于其它三个价值的环境中。它们相互支持。需要勇气来相信一路上具体反馈比预先知道每样事物来得更好。需要勇气来在可能暴露您的无知时与团队中其他人交流。需要勇气来使</FONT><A href="http://jizhuwo.com/System/index.html" target=_blank><FONT color=#000000 size=2>系统</FONT></A><FONT color=#000000 size=2>尽可能简单，将明天的决定推到明天做。而如果没有简单的</FONT><A href="http://jizhuwo.com/System/index.html" target=_blank><FONT color=#000000 size=2>系统</FONT></A><FONT color=#000000 size=2>、没有不断的交流来扩展知识、没有掌握方向所依赖的反馈，勇气也就失去了依靠。&nbsp;<BR><BR><BR>--------------------------------------------------------------------------------<BR><BR><BR></FONT><FONT color=#000000><FONT size=2><B>3 XP的十二种实践方法：&nbsp;<BR></B><BR><BR>重新划分（Refactoring）&nbsp;<BR><BR></FONT></FONT><A href="http://jizhuwo.com/System/index.html" target=_blank><FONT color=#000000 size=2>系统</FONT></A><FONT color=#000000 size=2>比喻(Metaphor)&nbsp;<BR><BR>简单设计(Simple design)&nbsp;<BR><BR>一周40小时 (40-hour week)&nbsp;<BR><BR>编码标准(Coding standards)&nbsp;<BR><BR>持续集成(Continuous integration)&nbsp;<BR><BR>成对编程(pair programming)&nbsp;<BR><BR>集体代码所有权(Collective ownership)&nbsp;<BR><BR>现场客户(On-site customer)&nbsp;<BR><BR>规划策略(Planning game)&nbsp;<BR><BR>小发行版(Small releases)&nbsp;<BR><BR>测试(Testing)&nbsp;<BR><BR>3.1 规划策略&nbsp;<BR>有些人会指责 XP 是一种美其名的剽窃，只是一群牛仔在没有任何规则的情况下将一个</FONT><A href="http://jizhuwo.com/System/index.html" target=_blank><FONT color=#000000 size=2>系统</FONT></A><FONT color=#000000 size=2>拼凑在一起。错。XP 是为数不多的几种承认您在开始时不可能事事通晓的方法之一。无论是用户还是开发人员都是随着项目的进展过程才逐步了解事物的。只有鼓励和信奉这种更改的方法才是有效方法。状态限定方法忽视更改。而 XP 则留心更改。它倾听所用的方法就是*规划策略*，一个由 Kent Beck 创造的概念。&nbsp;<BR>这一方法背后的主要思想是迅速地制定粗略计划，然后随着事物的不断清晰来逐步完善。规划策略的产物包括：一堆索引卡，每一张都包含一个客户素材，这些素材驱动项目的迭代；以及对下一两个发行版的粗略计划，如 Kent Beck 和 Martin Fowler 在他们的 Planning Extreme Programming 中描述的那样。让这种形式的计划得以发挥作用的关键因素是让用户做企业决策，让开发小组做技术决策。如果没有这一前提，整个过程就会土崩瓦解。&nbsp;<BR><BR>3.2 </FONT><A href="http://jizhuwo.com/System/index.html" target=_blank><FONT color=#000000 size=2>系统</FONT></A><FONT color=#000000 size=2>比喻&nbsp;<BR>体系结构是做什么用的？它提供了</FONT><A href="http://jizhuwo.com/System/index.html" target=_blank><FONT color=#000000 size=2>系统</FONT></A><FONT color=#000000 size=2>各种组件以及它们是如何交互的画面 -- 一种映射，可以让开发人员了解新的代码部分适合放在哪里。&nbsp;<BR>XP 中的</FONT><A href="http://jizhuwo.com/System/index.html" target=_blank><FONT color=#000000 size=2>系统</FONT></A><FONT color=#000000 size=2>比喻与大多数方法称作的体系结构差不多。比喻为团队提供了一致的画面，他们可以用它来描述现有</FONT><A href="http://jizhuwo.com/System/index.html" target=_blank><FONT color=#000000 size=2>系统</FONT></A><FONT color=#000000 size=2>的工作方式、新部件适合的位置，以及它们应该采取的形式。&nbsp;<BR>重要的是要记住，关键要让每个人理解</FONT><A href="http://jizhuwo.com/System/index.html" target=_blank><FONT color=#000000 size=2>系统</FONT></A><FONT color=#000000 size=2>是如何组合在一起的，而不是美丽的比喻。有时您就是无法想到一个好的比喻。想到时就太好了。　&nbsp;<BR><BR>3.3 测试&nbsp;<BR>在 XP 中有两种测试：&nbsp;<BR>1. 单元测试&nbsp;<BR>2. 验收测试&nbsp;<BR>开发人员在他们编写代码的同时编写单元测试。客户在他们定义了素材后编写验收测试。单元测试及时告诉开发人员</FONT><A href="http://jizhuwo.com/System/index.html" target=_blank><FONT color=#000000 size=2>系统</FONT></A><FONT color=#000000 size=2>在某一点上是否*工作*。验收测试告诉团队</FONT><A href="http://jizhuwo.com/System/index.html" target=_blank><FONT color=#000000 size=2>系统</FONT></A><FONT color=#000000 size=2>是否执行用户希望它执行的操作。&nbsp;<BR>假设团队使用的是如 Java 这样的面向对象语言，开发人员在为一些方法编写代码之前为每种有可能失败的方法编写单元测试。然后他们编写足够的代码使之能通过测试。有时人们会发现这有点奇怪。答案很简单。编写测试首先为您提供：&nbsp;<BR><BR>一组可能最完整的测试&nbsp;<BR><BR>可能能工作的最简单的代码&nbsp;<BR><BR>代码意图的明确景象&nbsp;<BR>开发人员只有在通过所有单元测试后才可以将代码检入到源代码资源库中。单元测试使开发人员有信心相信他们的代码能够工作。这为其他开发人员留下线索，可以帮助他们理解最早的开发人员的意图（实际上，这是我们看到过的最好的文档）。单元测试还给了开发人员勇气重新划分代码，因为测试失败可以立刻告诉开发人员存在错误。应该将单元测试自动化，并提供明确的通过／失败结果。xUnit 框架做到的远不止这些，因此大多数 XP 小组都使用它们。&nbsp;<BR>用户负责确保每个素材都有验收测试来确认它们。用户可以自己编写测试、可以征募组织中的其他成员（例如 QA 人员或业务分析员）编写它们，也可以将这两种方法结合起来。测试告诉他们</FONT><A href="http://jizhuwo.com/System/index.html" target=_blank><FONT color=#000000 size=2>系统</FONT></A><FONT color=#000000 size=2>是否具有应该具有的那些特性，以及是否可以正确工作。理想情况下，用户在迭代完成之前就应该写好迭代中那些素材的验收测试了。应该将验收测试自动化，并要经常运行来确保开发人员在实现新特性时没有破坏任何现有的特性。通常情况下，客户需要来自开发团队的某些帮助来编写验收测试。我们对一个项目开发一个可重用的自动验收测试框架，可以让用户在简单编辑器中输入他们的输入和所期望的输出。框架将输入转换成 XML </FONT><A href="http://jizhuwo.com/Soft/Tools/File/index.html" target=_blank><FONT color=#000000 size=2>文件</FONT></A><FONT color=#000000 size=2>、运行</FONT><A href="http://jizhuwo.com/Soft/Tools/File/index.html" target=_blank><FONT color=#000000 size=2>文件</FONT></A><FONT color=#000000 size=2>中的测试，然后为每个测试显示*通过*或*失败*。客户喜欢这一做法。&nbsp;<BR>不是所有验收测试都必须在所有情况下通过。问题是验收测试帮助客户衡量项目*完成*的情况如何。它们还可以让客户获悉有关某些事物是否可以发行的决定。&nbsp;<BR><BR>3.4 重构&nbsp;<BR>重构是在不更改功能性的前提下对代码加以改进。XP 小组在进行重构时毫不手软。&nbsp;<BR>开发人员重构有两个重要时机：实现特性之前和之后。开发人员尝试确定更改现有代码是否可以让新特性的开发更容易。他们查看刚刚写好的代码，看是否有方法可以对它进行简化。例如，如果他们认为有抽象的机会，就会进行重构来从具体实现中除去重复的代码。&nbsp;<BR>XP 建议您应该编写可能运行的最简单的代码，但同时也建议您应该不断学习。重构让您将学到的知识加入到代码中，同时又不会破坏测试。它使您的代码简练。这意味着它可以存在相当长的时间、为以后的开发人员引入更少问题，并为他们指引正确的方向。&nbsp;<BR><BR>3.5 成对编程&nbsp;<BR>使用 XP，成对的开发人员编写所有产品代码。这种方式听上去好象缺乏效率。Martin Fowler 说，*当人们说成对编程降低生产力时，我回答，'那是因为大多数耗费时间的编程部分是靠输入来完成的。'*实际上，成对编程无论在经济还是其它方面都提供了许多好处：&nbsp;<BR><BR>所有设计决策都牵涉到至少两个人。&nbsp;<BR><BR>至少有两个人熟悉</FONT><A href="http://jizhuwo.com/System/index.html" target=_blank><FONT color=#000000 size=2>系统</FONT></A><FONT color=#000000 size=2>的每一部分。&nbsp;<BR><BR>几乎不可能出现两个人同时疏忽测试或其它任务。&nbsp;<BR><BR>改变各对的组合在可以在团队范围内传播知识。&nbsp;<BR><BR>代码总是由至少一人复查。&nbsp;<BR>研究还显示成对的编程实际上比单独编程更有效。&nbsp;<BR><BR>3.6 小发行版&nbsp;<BR>发行版应该尽可能地小，同时仍然提供足够的企业价值以证明它们值得。&nbsp;<BR>只要觉得有意义就可以发布</FONT><A href="http://jizhuwo.com/System/index.html" target=_blank><FONT color=#000000 size=2>系统</FONT></A><FONT color=#000000 size=2>。这样就尽可能早为用户提供了价值（请记住，今天的钱比明天的钱来得值钱）。小发行版将为开发人员提供具体的反馈意见，告诉他们哪些符合客户需要，哪些不符合客户需要。然后，小组可以将这些经验教训包括在其下一发行版的规划中。&nbsp;<BR><BR>3.7 简单的设计&nbsp;<BR>XP 的诽谤者说该过程忽略了设计。事实不是这样。问题是重量型方法建议您做的不过是提前完成大部分琐碎的设计任务。这就象是拍一张静态的地平线的照片，静止不动，然后尝试画一张如何到达那里的完美的地图。XP 说设计不应该在事物将保持不变的前提下预先仓促进行。XP 认为设计非常重要，因此应该是一个持续的事务。我们总是先尝试使用能够工作的最简单的设计，然后随着现实的不断显现来更改它。&nbsp;<BR>什么是可能工作的最简单的设计？它是符合以下条件的设计：&nbsp;<BR><BR>运行所有测试&nbsp;<BR><BR>不包含重复代码&nbsp;<BR><BR>明确陈述</FONT><A href="http://jizhuwo.com/Dev/index.html" target=_blank><FONT color=#000000 size=2>程序</FONT></A><FONT color=#000000 size=2>员对所有代码的意图&nbsp;<BR><BR>包含尽可能最少的类和方法&nbsp;<BR>对简单设计的需求并不是说所有设计都很小，也不表示它们是无足轻重的。它们只不过需要尽可能简单，但是仍能工作。不要包括不使用的额外特性。我们称这样的事物为 YAGNI，表示*您将不需要它（You Aren't Going to Need It）。*不要让 YAGNI 破坏您成功的机会。&nbsp;<BR><BR>3.8 集体代码所有权&nbsp;<BR>小组中的任何人都应该有权对代码进行更改来改进它。每个人都拥有全部代码，这意味着每个人都对它负责。这种技术可以让人们对部分代码进行必要的更改而不用经过代码拥有者个人的瓶颈。每个人都负责这一事实消除了无代码所有权所带来的混乱。&nbsp;<BR><BR>每人拥有所有代码*与*没人拥有代码*的说法并不一样。没人拥有代码时，人们可以随处进行破坏而不必负任何责任。而 XP 说，*如果是您破坏的，应该您来弥补。*我们有一些必须在每次集成之前和之后运行的单元测试。如果您破坏了某些事物，您要负责进行修补，无论它位于代码的哪一部分。这需要极端规则。可能这是名称中带有*极端*的另一个原因。&nbsp;<BR><BR>3.9 持续的集成&nbsp;<BR>经常进行代码集成可以帮助您避免集成梦魇。XP 团队在一天中集成了代码几次，每次都在所有单元测试对</FONT><A href="http://jizhuwo.com/System/index.html" target=_blank><FONT color=#000000 size=2>系统</FONT></A><FONT color=#000000 size=2>运行后执行。&nbsp;<BR>传统方法工作方式如下：编写大量代码后执行一次大爆炸式的集成，然后花费相当长的时间来改正问题。这种笨拙的形式的确使项目速度减缓。大爆炸式的集成给团队立即带来大量问题，并且这些问题通常都有几百种可能的原因。&nbsp;<BR>如果经常进行集成，任何特定集成失败的原因都会非常明显（以前运行过测试，因此错误一定是新事物犯下的）。使用这种方法，当遇到问题时，可能的原因就相当有限。修改起来更容易，花的时间少得多，使团队保持最快速度前进。&nbsp;<BR><BR>3.10 现场客户&nbsp;<BR>要使功能最理想，XP 小组需要在现场有一位客户来明确素材，并做出重要的企业决策。开发人员是不允许单独做这些事情的。让客户随时在场可以消除开发人员等待决策时出现的瓶颈。&nbsp;<BR>XP 不会假装素材卡是开发人员交付必要代码所需的唯一指示。素材是对以后在客户和开发人员之间填写细节的对话的一项承诺。与将所有要求写在一个静态文档中不同，其思想是进行面对面的交流，减少产生误解的机会。&nbsp;<BR>我们发现让客户在现场是可能最好的一种情形，但这不是解决问题的唯一方案。底线是客户必须随时在需要回答问题和根据企业价值为团队提供指示时有空。如果客户并非在现场专职陪伴团队的情况下就能做到这些，那很好。如果能和团队待在一起，这会更方便，但只是建议而已。&nbsp;<BR><BR>3.11 编码标准&nbsp;<BR>拥有编码标准有两个目的：&nbsp;<BR><BR>防止团队被一些例如事物没有以最大速度发展这种无关紧要的愚蠢争论搞得不知所措。&nbsp;<BR><BR>它支持其它方法。&nbsp;<BR>如果没有编码标准，重新划分代码会更加困难，按应当的频度交换对更困难，快速前进也更困难。目标应该是团队中没有人辨认得出是谁写的哪一部分代码。以团队为单位对某一标准达成协议，然后遵守这一标准。目标不是创建一个事无巨细的规则列表，而是提供将确保您的代码可以清晰交流的指导方针。编码标准开始时应该很简单，然后根据团队经验逐步进化。不要预先花费太多时间。创建能够工作的最简单标准，然后逐步发展。&nbsp;<BR><BR>3.12 一周 40 小时&nbsp;<BR>Kent Beck 说他希望*...每天早晨都感到有活力有激情，每天晚上都感到疲惫而满足。*一周 40 小时工作可以让您做到这一点。确切的小时数并不重要，重要的是原则。长时间地持续工作会扼杀工作绩效。疲劳的开发人员会犯更多错误，从长期来说，将比按*正常*时间表进行的开发慢得多。&nbsp;<BR>即使开发人员可以在长时间很好工作，这也不意味着他们应该这样。最终他们会厌倦，会离开他们的工作，或者产生影响他们工作绩效的非工作问题。如果您打乱了人们的生活，将会尝到它所带来的恶果。加班并不是解决项目问题的答案。实际上，它是更大问题的症状。如果您要走向灭亡，就无药可救了。&nbsp;<BR><BR><BR>--------------------------------------------------------------------------------<BR><BR><BR></FONT><FONT color=#000000><FONT size=2><B>4 XP过程中的各个阶段<BR></B><BR>作为一个软件开发过程，XP中计划，设计，编码和测试各阶段包括的内容比较简洁，容易实施。&nbsp;<BR><BR>4.1 计划&nbsp;<BR><BR>User stories的编写&nbsp;<BR><BR>识别需求方面&nbsp;<BR><BR>开发计划的制定&nbsp;<BR><BR>经常构造版本&nbsp;<BR><BR>版本控制&nbsp;<BR><BR>Load Factor因子的确定&nbsp;<BR><BR>将项目分解为各个迭代期&nbsp;<BR><BR>每个迭代期开始时制定计划&nbsp;<BR><BR>人员集中&nbsp;<BR><BR>站着开每日晨会&nbsp;<BR><BR>当实施遇到困难时及时修正&nbsp;<BR><BR>4.2 测试&nbsp;<BR><BR>所有代码均需进行单元测试&nbsp;<BR><BR>发行之前所有代码必须通过单元测试&nbsp;<BR><BR>Bug发现后应马上测试 　&nbsp;<BR><BR>4.3 编码&nbsp;<BR><BR>始终获得用户的支持&nbsp;<BR><BR>代码的书写必须按照规范&nbsp;<BR><BR>所有代码均采用配对开发&nbsp;<BR><BR>一次只能有一对开发人员进行发行&nbsp;<BR><BR>代码经常集成&nbsp;<BR><BR>代码共享&nbsp;<BR><BR>将优化放在最后&nbsp;<BR><BR>不要加班&nbsp;<BR><BR>4.4 设计&nbsp;<BR><BR>简单化&nbsp;<BR>采用编程规范&nbsp;<BR>设计时使用CRC卡片&nbsp;<BR>使用Spike Solution 方法&nbsp;<BR>不要过早添加新功能&nbsp;<BR>尽可能保持</FONT></FONT><A href="http://jizhuwo.com/Dev/index.html" target=_blank><FONT color=#000000 size=2>程序</FONT></A><FONT color=#000000 size=2>的简洁性&nbsp;<BR>--------------------------------------------------------------------------------<BR><BR></FONT><FONT color=#000000><FONT size=2><B>5 相关资料<BR></B>Extremeprogramming: http://www.extremeprogramming.org/<BR>XPdeveloper: http://http://www.xpdeveloper.com/<BR>Xprogramming: http://www.xprogramming.com/<BR>Junit: http://www.junit.org/<BR></FONT></FONT><img src ="http://www.blogjava.net/chenpengyi/aggbug/31546.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/chenpengyi/" target="_blank">陈朋奕</a> 2006-02-19 21:04 <a href="http://www.blogjava.net/chenpengyi/articles/31546.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item></channel></rss>