﻿<?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-&lt;h2&gt;&lt;font color="green"&gt;生命科学领域的专业信息解决方案！&lt;/font&gt;&lt;/h2&gt;-随笔分类-软件工程</title><link>http://www.blogjava.net/rain1102/category/37668.html</link><description>&lt;br/&gt;&lt;font color="green" style="font-family: 华文行楷;font-size:16px;"&gt;化学结构搜索，化学信息学，生物信息学，实验室信息学等
。&lt;/font&gt;&lt;br/&gt;&lt;font color="#3C1435"&gt;以高科技的生物、化学信息技术实现生命科学领域中专业数据的计算和管理、提高研发能力、增强在科研和成本效率方面的国际竞争力，为生物、化学、医药和学术机构提供一流的解决方案和技术咨询。&lt;/font&gt;&lt;br/&gt;
&lt;br/&gt;&lt;font color="green" style="font-family: 华文行楷;font-size:16px;"&gt;子曰：危邦不入，乱邦不居。天下有道则见，无道则隐。&lt;/font&gt;&lt;font color="#3C1435"&gt;&lt;/font&gt;&lt;br/&gt;
</description><language>zh-cn</language><lastBuildDate>Thu, 11 Aug 2011 12:41:47 GMT</lastBuildDate><pubDate>Thu, 11 Aug 2011 12:41:47 GMT</pubDate><ttl>60</ttl><item><title>程序员、设计师、项目经理之间的战争</title><link>http://www.blogjava.net/rain1102/archive/2011/08/11/356300.html</link><dc:creator>周锐</dc:creator><author>周锐</author><pubDate>Thu, 11 Aug 2011 06:47:00 GMT</pubDate><guid>http://www.blogjava.net/rain1102/archive/2011/08/11/356300.html</guid><wfw:comment>http://www.blogjava.net/rain1102/comments/356300.html</wfw:comment><comments>http://www.blogjava.net/rain1102/archive/2011/08/11/356300.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/rain1102/comments/commentRss/356300.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/rain1102/services/trackbacks/356300.html</trackback:ping><description><![CDATA[<img src="http://www.blogjava.net/images/blogjava_net/rain1102/程序员_设计师_项目经理之间的战争.jpg" alt="" /><img src ="http://www.blogjava.net/rain1102/aggbug/356300.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/rain1102/" target="_blank">周锐</a> 2011-08-11 14:47 <a href="http://www.blogjava.net/rain1102/archive/2011/08/11/356300.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>28条提高关键字排名的SEO优化方法【转载】</title><link>http://www.blogjava.net/rain1102/archive/2011/06/29/353366.html</link><dc:creator>周锐</dc:creator><author>周锐</author><pubDate>Wed, 29 Jun 2011 07:44:00 GMT</pubDate><guid>http://www.blogjava.net/rain1102/archive/2011/06/29/353366.html</guid><wfw:comment>http://www.blogjava.net/rain1102/comments/353366.html</wfw:comment><comments>http://www.blogjava.net/rain1102/archive/2011/06/29/353366.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/rain1102/comments/commentRss/353366.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/rain1102/services/trackbacks/353366.html</trackback:ping><description><![CDATA[<span class="Apple-style-span" style="color: #bbbbbb; font-family: arial; font-size: 13px; line-height: 26px; "><h3 style="outline-width: medium; outline-style: none; outline-color: initial; font-size: 14px; font-weight: bold; color: #cccccc; "><span style="color: #000000; ">关键词位置、密度、处理</span></h3></span><span class="Apple-style-span" style="font-family: arial; font-size: 13px; line-height: 26px; color: #000000; ">1.URL中出现关键词（英文）<br style="outline-width: medium; outline-style: none; outline-color: initial; " /></span><span class="Apple-style-span" style="font-family: arial; font-size: 13px; line-height: 26px; color: #000000; ">2.网页标题中出现关键词（1-3个）<br style="outline-width: medium; outline-style: none; outline-color: initial; " /></span><span class="Apple-style-span" style="font-family: arial; font-size: 13px; line-height: 26px; color: #000000; ">3.关键词标签中出现关键词（1-3个）<br style="outline-width: medium; outline-style: none; outline-color: initial; " /></span><span class="Apple-style-span" style="font-family: arial; font-size: 13px; line-height: 26px; color: #000000; ">4.描述标签中出现关键词（主关键词重复2次）<br style="outline-width: medium; outline-style: none; outline-color: initial; " /></span><span class="Apple-style-span" style="font-family: arial; font-size: 13px; line-height: 26px; color: #000000; ">5.内容中自然出现关键词<br style="outline-width: medium; outline-style: none; outline-color: initial; " /></span><span class="Apple-style-span" style="font-family: arial; font-size: 13px; line-height: 26px; color: #000000; ">6.内容第一段和最后一段出现关键词<br style="outline-width: medium; outline-style: none; outline-color: initial; " /></span><span class="Apple-style-span" style="font-family: arial; font-size: 13px; line-height: 26px; color: #000000; ">7.H1，H2标签中出现关键词<br style="outline-width: medium; outline-style: none; outline-color: initial; " /></span><span class="Apple-style-span" style="font-family: arial; font-size: 13px; line-height: 26px; color: #000000; ">8.导出链接锚文本中包含关键词<br style="outline-width: medium; outline-style: none; outline-color: initial; " /></span><span class="Apple-style-span" style="font-family: arial; font-size: 13px; line-height: 26px; color: #000000; ">9.图片的文件名包含关键词<br style="outline-width: medium; outline-style: none; outline-color: initial; " /></span><span class="Apple-style-span" style="font-family: arial; font-size: 13px; line-height: 26px; color: #000000; ">10.ALT属性中出现关键词<br style="outline-width: medium; outline-style: none; outline-color: initial; " /></span><span class="Apple-style-span" style="font-family: arial; font-size: 13px; line-height: 26px; color: #000000; ">11.关键词密度6-8%<br style="outline-width: medium; outline-style: none; outline-color: initial; " /></span><span class="Apple-style-span" style="font-family: arial; font-size: 13px; line-height: 26px; color: #000000; ">12.对关键词加粗或斜体<br style="outline-width: medium; outline-style: none; outline-color: initial; " /><h3 style="outline-width: medium; outline-style: none; outline-color: initial; font-size: 14px; font-weight: bold; color: #cccccc; "><span style="color: #000000; ">内容质量、更新频率、相关性</span></h3></span><span class="Apple-style-span" style="font-family: arial; font-size: 13px; line-height: 26px; color: #000000; ">1.原创的内容最佳，切忌被多次转载的内容<br style="outline-width: medium; outline-style: none; outline-color: initial; " /></span><span class="Apple-style-span" style="font-family: arial; font-size: 13px; line-height: 26px; color: #000000; ">2.内容独立性，与其他页面至少30%互异<br style="outline-width: medium; outline-style: none; outline-color: initial; " /></span><span class="Apple-style-span" style="font-family: arial; font-size: 13px; line-height: 26px; color: #000000; ">3.1000-2000字，合理分段<br style="outline-width: medium; outline-style: none; outline-color: initial; " /></span><span class="Apple-style-span" style="font-family: arial; font-size: 13px; line-height: 26px; color: #000000; ">4.有规律更新，最好是每天<br style="outline-width: medium; outline-style: none; outline-color: initial; " /></span><span class="Apple-style-span" style="font-family: arial; font-size: 13px; line-height: 26px; color: #000000; ">5.内容围绕页面关键词展开，与整站主题相关<br style="outline-width: medium; outline-style: none; outline-color: initial; " /></span><span class="Apple-style-span" style="font-family: arial; font-size: 13px; line-height: 26px; color: #000000; ">6.具有评论功能，评论中出现关键词<br style="outline-width: medium; outline-style: none; outline-color: initial; " /><h3 style="outline-width: medium; outline-style: none; outline-color: initial; font-size: 14px; font-weight: bold; color: #cccccc; "><span style="color: #000000; ">导入链接和锚文本</span></h3></span><span class="Apple-style-span" style="font-family: arial; font-size: 13px; line-height: 26px; "><p style="outline-width: medium; outline-style: none; outline-color: initial; "><span style="color: #000000; ">1.高PR值站点的导入链接</span><br style="outline-width: medium; outline-style: none; outline-color: initial; " /><span style="color: #000000; ">2.内容相关页面的导入链接</span><br style="outline-width: medium; outline-style: none; outline-color: initial; " /><span style="color: #000000; ">3.导入链接锚文本中包含页面关键词</span><br style="outline-width: medium; outline-style: none; outline-color: initial; " /><span style="color: #000000; ">4.锚文本存在于网页内容中</span><br style="outline-width: medium; outline-style: none; outline-color: initial; " /><span style="color: #000000; ">5.锚文本周围出现相关关键词</span><br style="outline-width: medium; outline-style: none; outline-color: initial; " /><span style="color: #000000; ">6.导入链接存在3个月以上</span><br style="outline-width: medium; outline-style: none; outline-color: initial; " /><span style="color: #000000; ">7.导入链接所在页面的导出链接少于100个</span><br style="outline-width: medium; outline-style: none; outline-color: initial; " /><span style="color: #000000; ">8.导入链接来自不同IP地址</span><br style="outline-width: medium; outline-style: none; outline-color: initial; " /><span style="color: #000000; ">9.导入链接自然增加</span><br style="outline-width: medium; outline-style: none; outline-color: initial; " /><span style="color: #000000; ">10.锚文本多样化（如，SEO和SEO十万个为什么）<br /></span><span style="color: #000000; ">原文地址：<div style="display: inline-block; "></div></span></p></span><a href="http://www.gbin1.com/technology/seo/28waytoseo/"><span style="color: #000000; ">http://www.gbin1.com/technology/seo/28waytoseo/</span></a><img src ="http://www.blogjava.net/rain1102/aggbug/353366.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/rain1102/" target="_blank">周锐</a> 2011-06-29 15:44 <a href="http://www.blogjava.net/rain1102/archive/2011/06/29/353366.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>MapReduce</title><link>http://www.blogjava.net/rain1102/archive/2009/11/18/302753.html</link><dc:creator>周锐</dc:creator><author>周锐</author><pubDate>Wed, 18 Nov 2009 01:00:00 GMT</pubDate><guid>http://www.blogjava.net/rain1102/archive/2009/11/18/302753.html</guid><wfw:comment>http://www.blogjava.net/rain1102/comments/302753.html</wfw:comment><comments>http://www.blogjava.net/rain1102/archive/2009/11/18/302753.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/rain1102/comments/commentRss/302753.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/rain1102/services/trackbacks/302753.html</trackback:ping><description><![CDATA[<p><strong>MapReduce</strong>是Google提出的一个软件架构，用于大规模数据集（大于1TB）的并行运算。概念"Map（映射）"和"Reduce（化简）"，和他们的主要思想，都是从函数式编程语言借来的，还有从矢量编程语言借来的特性。</p>
<p>当前的软件实现是指定一个<em>Map（映射）</em>函数，用来把一组键值对映射成一组新的键值对，指定并发的<em>Reduce（化简）</em>函数，用来保证所有映射的键值对中的每一个共享相同的键组。</p>
<script type="text/javascript">
//<![cdata[ if (window.showTocToggle) { var tocshowtext="显示" ; var tochidetext="隐藏" ; showTocToggle(); } 
//]]&gt;
</script>
<h2><span class="mw-headline" id=".E6.98.A0.E5.B0.84.E5.92.8C.E5.8C.96.E7.AE.80">映射和化简</span></h2>
<p>简单说来，一个映射函数就是对一些独立元素组成的概念上的列表（例如，一个测试成绩的列表）的每一个元素进行指定的操作（比如前面的例子里，有人发现所有学生的成绩都被高估了一分，他可以定义一个&#8220;减一&#8221;的映射函数，用来修正这个错误。）。事实上，每个元素都是被独立操作的，而原始列表没有被更改，因为这里创建了一个新的列表来保存新的答案。这就是说，Map操作是可以高度并行的，这对高性能要求的应用以及并行计算领域的需求非常有用。</p>
<p>而化简操作指的是对一个列表的元素进行适当的合并（继续看前面的例子，如果有人想知道班级的平均分该怎么做？他可以定义一个化简函数，通过让列表中的元素跟自己的相邻的元素相加的方式把列表减半，如此递归运算直到列表只剩下一个元素，然后用这个元素除以人数，就得到了平均分）。虽然他不如映射函数那么并行，但是因为化简总是有一个简单的答案，大规模的运算相对独立，所以化简函数在高度并行环境下也很有用。</p>
<h2><span class="mw-headline" id=".E5.88.86.E5.B8.83.E5.92.8C.E5.8F.AF.E9.9D.A0.E6.80.A7">分布和可靠性</span></h2>
<p>MapReduce通过把对数据集的大规模操作分发给网络上的每个节点实现可靠性；每个节点会周期性的把完成的工作和状态的更新报告回来。如果一个节点保持沉默超过一个预设的时间间隔，主节点（类同Google档案系统中的主服务器）记录下这个节点状态为死亡，并把分配给这个节点的数据发到别的节点。每个操作使用命名文件的原子操作以确保不会发生并行线程间的冲突；当文件被改名的时候，系统可能会把他们复制到任务名以外的另一个名字上去。（避免副作用）。</p>
<p>化简操作工作方式很类似，但是由于化简操作在并行能力较差，主节点会尽量把化简操作调度在一个节点上，或者离需要操作的数据尽可能近的节点上了；这个特性可以满足Google的需求，因为他们有足够的带宽，他们的内部网络没有那么多的机器。</p>
<h2><span class="mw-headline" id=".E7.94.A8.E9.80.94">用途</span></h2>
<p>在Google，MapReduce用在非常广泛的应用程序中，包括&#8220;分布grep，分布排序，web连接图反转，每台机器的词矢量，web访问日志分析，反向索引构建，文档聚类，机器学习，基于统计的机器翻译&#8230;&#8230;&#8221;值得注意的是，MapReduce实现以后，它被用来重新生成Google的整个索引，并取代老的ad hoc程序去更新索引。</p>
<p>MapReduce会生成大量的临时文件，为了提高效率，它利用Google档案系统来管理和访问这些文件。</p>
<h2><span class="mw-headline" id=".E5.85.B6.E4.BB.96.E5.AE.9E.E7.8E.B0">其他实现</span></h2>
<ul>
    <li>Hadoop － Apache软件基金会的开放源码项目，提供与MapReduce档案系统类似的功能。 </li>
</ul><img src ="http://www.blogjava.net/rain1102/aggbug/302753.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/rain1102/" target="_blank">周锐</a> 2009-11-18 09:00 <a href="http://www.blogjava.net/rain1102/archive/2009/11/18/302753.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>团队制胜:掌握软件项目成功主动权</title><link>http://www.blogjava.net/rain1102/archive/2009/09/14/295076.html</link><dc:creator>周锐</dc:creator><author>周锐</author><pubDate>Mon, 14 Sep 2009 14:15:00 GMT</pubDate><guid>http://www.blogjava.net/rain1102/archive/2009/09/14/295076.html</guid><wfw:comment>http://www.blogjava.net/rain1102/comments/295076.html</wfw:comment><comments>http://www.blogjava.net/rain1102/archive/2009/09/14/295076.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/rain1102/comments/commentRss/295076.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/rain1102/services/trackbacks/295076.html</trackback:ping><description><![CDATA[第一部分 问题空间<br />
第1章 我们面临的巨大挑战<br />
1.1 困难<br />
1.2 缺乏远见的解决方案<br />
1.3 人力因素的脆弱性<br />
1.4 最优方法的真相<br />
1.5 小结<br />
<br />
文档可以用来传达信息，但不能用来替代讨论过程。真正能给团队带来价值的并不是计划本身，而是制定计划的过程。<br />
大量的低效工作、令人难以接手的产品质量、以及低落的员工士气等等，这些都是在许多公司中司空见惯的现象，即使其中的某些公司从商业的角度来看可以算是成功的。他们继续艰难地行进着，为&#8220;足够好&#8221;设定一个很低的标准，并且没有意识到提高工作效率的关键因素其实就在于他们自己。<br />
随着团队规模的增大，共同的认识将趋于下降，这是因为团队之间的沟通没有得到充分地管理。我们必须不断努力改善沟通工作以及促进团队理解。<br />
<br />
在当前组织中，你要思考那些对你产生影响或者你正在实施的改进措施。是否盲目地遵循其他人推荐的方法？是否盲目的采用了一些工具？<br />
<br />
<br />
第2章 做正确的事<br />
2.1 正确地做事与做正确的事<br />
2.2 做事的方式<br />
2.3 我们需要掌控成功<br />
2.4 解决方案框架<br />
2.5 小结<br />
<br />
软件开发是一种创造性的活动，是由人（有着情绪、感情、需求和关注等，这些因素是多样性的，而且也是重要的）来完成的。<br />
沟通需要是准确的、公开化的和透明的。不能进行一些秘密的讨论，并且需要更主动地进行倾听。在进行讨论之前，需要进行换为思考。倾听并不只是等待时机来表达我们的不同意见、或者等待适当的时机来说出我们的观点、或者容忍其他人的异议，倾听的主要目的是了解其他人的观点。<br />
要想实现大目标，就需要从小的目标做起。你将如何与团队进行互动以确保你将掌控成功，而不是由于你所面对的问题来指责别人！<br />
<br />
<br />
第二部分 个人<br />
第3章 个人的正确态度<br />
3.1 牛仔和无名英雄<br />
3.2 合理的自我批评<br />
3.3 情绪<br />
3.4 加快进度<br />
3.5 我们都是领导者<br />
3.6 小结<br />
<br />
懒惰－已知的忽视<br />
忽视－未知的忽视<br />
技能缺乏－已知的未知<br />
缺乏认识－未知的未知<br />
《一分钟经理人》 －《The One-Minute Manager》<br />
在没有彻底领悟优秀领导者的特质之前，不要急于搬进总裁办公室。<br />
如果等到成为负责人时你才注意这些特质，那么为时已晚。<br />
<br />
<br />
第4章 以质量为中心<br />
4.1 质量是一种责任<br />
4.2 输出质量理念<br />
4.3 按照人员、过程、产品的顺序<br />
4.4 小结<br />
<br />
无论你在公司中的职位是什么，如果你认为质量根本就是别人的责任，那么就已经完全忽视了产品质量。无论你的职位是什么，你自己都要确保工作不会破坏整体产品的质量。质量是你的责任之一。<br />
成功的外包需要在项目迁移的过程中对价值观和态度进行积极的管理。<br />
如果始终以质量为中心，并且能够有意识地把这种思维传播到团队中，那么无论在什么地方都会取得成功。<br />
如果真地想要提高产品的质量，那么首先应该提高产品开发团队的质量，然后才是提高在开发过程中使用的一些过程的质量。只有这些质量都已经得到提高之后，才能期望产品的质量正是你想要的结果。如果没有做到这些，那么所有的承诺都不过是空话。<br />
<br />
第5章 面对挑战<br />
5.1 感受痛苦<br />
5.2 应对痛苦<br />
5.3 否定<br />
5.4 忽视<br />
5.5 毅力<br />
5.6 思维定式<br />
5.7 小结<br />
<br />
第6章 主动性成效<br />
6.1 认识你自己<br />
6.2 赌徒与冒险家<br />
6.3 设计我们的环境<br />
6.4 并行工作<br />
6.5 决策<br />
6.6 坚持到底<br />
6.7 小结<br />
<br />
第7章 可持续性<br />
7.1 什么才是重要的<br />
7.2 充电<br />
7.3 闻一闻玫瑰的花香<br />
7.4 将内省作为一种商业策略<br />
7.5 生活质量<br />
7.6 小结<br />
<br />
第三部分 群体<br />
第8章 沟通<br />
8.1 表达自己的意见<br />
8.2 舒适的沟通<br />
8.3 全面公开<br />
8.4 信任<br />
8.5 客户满意度<br />
8.6 明确性和共同的理解<br />
8.7 沟通的消极面<br />
8.8 小结<br />
<br />
第9章 动机与期望<br />
9.1 动机驱动行为<br />
9.2 成为一个激励者<br />
9.3 公开我们的动机<br />
9.4 反思阿喀琉斯之踵<br />
9.5 期望<br />
9.6 管理我们的期望<br />
9.7 没有消息其实就是最坏的消息<br />
9.8 小结<br />
<br />
第10章 合作愉快<br />
10.1 技术赎金<br />
10.2 游戏<br />
10.3 工作保障<br />
10.4 谣言和暗讽<br />
10.5 尽量减少干扰<br />
10.6 质量圈族谱<br />
10.7 就像在家里一样<br />
10.8 小结<br />
<br />
第四部分 团队<br />
第11章 一致性<br />
11.1 团队保持一致<br />
11.2 团队规模的增长<br />
11.3 与团队保持步调一致<br />
11.4 制订规则<br />
11.5 有意识的团队契约<br />
11.6 包容各种观点<br />
11.7 按比例缩放<br />
11.8 小结<br />
<br />
第12章 组织<br />
12.1 各得其所<br />
12.2 已定义方法，还是科幻小说<br />
12.3 过程架构<br />
12.4 阅读组合方法说明中的小字内容<br />
12.5 这是一个过程项目吗<br />
12.6 通过优化提升速度<br />
12.7 培训<br />
12.8 当问题出现时<br />
12.9 但是我们不在乎<br />
12.10 有条理的讨论<br />
12.11 小结<br />
<br />
第13章 协调<br />
13.1 清理路障，还是阻塞道路<br />
13.2 开诚布公的管理<br />
13.3 只是一名雇员吗<br />
13.4 检出，检入<br />
13.5 对文档化工作的态度<br />
13.6 不要轻易地将一切都外包<br />
13.7 有人情味的平衡<br />
13.8 保留上下文<br />
13.9 小结<br />
<br />
第14章 指导<br />
14.1 胡萝卜和大棒<br />
14.2 可控的多样性<br />
14.3 是懒惰还是创造力<br />
14.4 捷径<br />
14.5 过程工效学<br />
14.6 规模并不重要<br />
14.7 持续的一致性<br />
14.8 小结<br />
<br />
第五部分 利益相关者<br />
第15章 客户<br />
15.1 谁是我们的客户<br />
15.2 终端客户的代表<br />
15.3 真实可靠<br />
15.4 掌控期望<br />
15.5 小结<br />
<br />
第16章 设定目标<br />
16.1 目标和任务<br />
16.2 定义成功<br />
16.3 根据产品的优势调整优先次序<br />
16.4 是否真正重视产品质量<br />
16.5 滑坡<br />
16.6 全局观<br />
16.7 小结<br />
<br />
第17章 规范<br />
17.1 意外的规范<br />
17.2 规范的锥体特性<br />
17.3 保持领先一步<br />
17.4 到什么程度才是足够的<br />
17.5 小结<br />
<br />
第18章 优先级<br />
18.1 正确的开端<br />
18.2 在确定优先级之前首先制定计划<br />
18.3 优先级排序<br />
18.4 衡量和确定项目范围的优先级<br />
18.5 拖延带来的成本<br />
18.6 小结<br />
<br />
第19章 变更<br />
19.1 变动性要求多样性<br />
19.2 偏离预计路线<br />
19.3 通过配置管理来了解我们当时的思考<br />
19.4 只需再多一点<br />
19.5 小结<br />
<br />
第20章 进展<br />
20.1 三个关键角色<br />
20.2 一种有条理的方法<br />
20.3 解决难题<br />
20.4 有风险的业务<br />
20.5 关键路径<br />
20.6 文档签字的含义<br />
20.7 知道何时退出<br />
20.8 完成<br />
20.9 小结<br />
<br />
第六部分 理清思路<br />
第21章 挑选目标<br />
21.1 正确的过程<br />
21.2 规则<br />
21.3 解耦项目<br />
21.4 亡羊补牢<br />
21.5 小结<br />
<br />
第22章 灵活性和严格性<br />
22.1 指导与规定<br />
22.2 检查列表与签字<br />
22.3 真正的设计问题：多样化和趋同<br />
22.4 文档化和公共知识<br />
22.5 避免发展过程中的复杂性<br />
22.6 张贴出来<br />
22.7 小结<br />
<br />
第23章 回顾进展<br />
23.1 将量化作为一项必要工作<br />
23.2 战术度量和战略度量<br />
23.3 隐性消耗<br />
23.4 不能太大，也不能太小<br />
23.5 小结<br />
<br />
第24章 回顾变更<br />
24.1 为变更制定计划<br />
24.2 去掉旧方法<br />
24.3 对未来的工作分类<br />
24.4 机会<br />
24.5 采取小的、可量化的步骤<br />
24.6 提高认识<br />
24.7 小结<br />
<br />
第25章 始终保持警惕<br />
25.1 眼罩<br />
25.2 有哪些伤害<br />
25.3 倒退<br />
25.4 小结<br />
<br />
第七部分 附录<br />
核心工具<br /><img src ="http://www.blogjava.net/rain1102/aggbug/295076.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/rain1102/" target="_blank">周锐</a> 2009-09-14 22:15 <a href="http://www.blogjava.net/rain1102/archive/2009/09/14/295076.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>项目中遇到的性能问题总结</title><link>http://www.blogjava.net/rain1102/archive/2009/08/05/289965.html</link><dc:creator>周锐</dc:creator><author>周锐</author><pubDate>Wed, 05 Aug 2009 08:27:00 GMT</pubDate><guid>http://www.blogjava.net/rain1102/archive/2009/08/05/289965.html</guid><wfw:comment>http://www.blogjava.net/rain1102/comments/289965.html</wfw:comment><comments>http://www.blogjava.net/rain1102/archive/2009/08/05/289965.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/rain1102/comments/commentRss/289965.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/rain1102/services/trackbacks/289965.html</trackback:ping><description><![CDATA[<p>最近一直从事的项目中遇到不少性能问题, 虽然表中的数据数量不是太大, 最大也就200万条, 其他基本都是100万左右, 但由于存在一个化合物结构信息的数据使得数据库特别的大, 就dmp文件就达到4G多。而客户对性能要求又比较高。目前遇到问题以及解决方案(并非最佳方案)总结如下:<br />
</p>
1. 多表查询时候速度慢: 为表之间关联列创建索引, 只取需要数据。<br />
2. 多条数据批量更新: 尽量使用原生SQL, 少用Hibernate取了循环再更新。<br />
3. 数据量大查询时候少用upper，lower等类似数据提供的功能函数去转换数据，可以考虑是否在存入数据之前就把所有数据改为大写或者小写，显示时候再按要求格式化内容。<br />
4. 使用Hibernate时候，把关联关系尽量设置成延迟加载，然后使用时候再用fetch取出。<br />
<br />
目前先总结这些， 遇到再加。<img src ="http://www.blogjava.net/rain1102/aggbug/289965.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/rain1102/" target="_blank">周锐</a> 2009-08-05 16:27 <a href="http://www.blogjava.net/rain1102/archive/2009/08/05/289965.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>工作三年之回顾</title><link>http://www.blogjava.net/rain1102/archive/2009/07/21/287679.html</link><dc:creator>周锐</dc:creator><author>周锐</author><pubDate>Tue, 21 Jul 2009 09:10:00 GMT</pubDate><guid>http://www.blogjava.net/rain1102/archive/2009/07/21/287679.html</guid><wfw:comment>http://www.blogjava.net/rain1102/comments/287679.html</wfw:comment><comments>http://www.blogjava.net/rain1102/archive/2009/07/21/287679.html#Feedback</comments><slash:comments>1</slash:comments><wfw:commentRss>http://www.blogjava.net/rain1102/comments/commentRss/287679.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/rain1102/services/trackbacks/287679.html</trackback:ping><description><![CDATA[三年了，真不敢相信现实，自己竟然已经毕业三年多了。从实习到现在已经三年半。<br />
三年前的今天在做什么自己都记得不是太清楚了，估计还在那里了解公司的主要项目架构，了解里面的主要代码。一个给政府做的门户网站的框架代码，之后也就在这基础上做了昆山市政府的门户网站。记忆最深的，就是为什么每次数据库连接的关闭不分装好，而需要自己手动去关闭，现在应该早解决了吧。虽然短短的十个月，但那里是我步入社会的第一个脚印，也是第一次参与正式项目。真心希望网进越走越好。<br />
毕业后的第二份工作，也就是现在的，方正软件，一个刚成立的公司，开始有很多苛刻让人气愤的规定，到目前为止大部分被取消了，当然还存在一些恶心的规定。比如公积金按照工资的80%来交，而税则按照所有钱加起来来交，就连吃饭的钱也交税。既然还在这里做，就安心的工作，做好眼前的事，这样才对得起自己的时间。毕竟公司一步一步走到现在也不容易，希望公司早日发展并壮大。<br />
两年半的方正职业生涯虽然没做过什么大的项目，但自己也学习到了不少东西，包括技术，做人，管理等等。当然最重要的还是在这里认识了几个好朋友。不管以后如何，获得的这些东西对我来说都是很珍贵的，对我以后的职业以及生活都会有很大帮助的。<br />
三年前，感觉遇到三年以上工作经验的人是多么的神圣与幸运，现在看来，原来也就那样，如果一个人真的厉害真的有悟性，根本不需要3年，就可以达到很高的境界，而如果程序员对程序不来电，没有悟性，或者说心思不放在代码上，给他三年，五年，甚至十年也不会有多大的突破。<br />
最后，希望以后的路继续走好！<img src ="http://www.blogjava.net/rain1102/aggbug/287679.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/rain1102/" target="_blank">周锐</a> 2009-07-21 17:10 <a href="http://www.blogjava.net/rain1102/archive/2009/07/21/287679.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>用户体验的要素</title><link>http://www.blogjava.net/rain1102/archive/2009/05/25/277897.html</link><dc:creator>周锐</dc:creator><author>周锐</author><pubDate>Mon, 25 May 2009 13:11:00 GMT</pubDate><guid>http://www.blogjava.net/rain1102/archive/2009/05/25/277897.html</guid><wfw:comment>http://www.blogjava.net/rain1102/comments/277897.html</wfw:comment><comments>http://www.blogjava.net/rain1102/archive/2009/05/25/277897.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/rain1102/comments/commentRss/277897.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/rain1102/services/trackbacks/277897.html</trackback:ping><description><![CDATA[<p>从低向上为战略层、范围层、 结构层、 框架层和表现层<br />
<strong>战略层(strategy)——网站目标和用户需求</strong><br />
成功的用户体验，其基础是一个被明确表达的&#8220;战略&#8221;。知道企业与用户双方对网站的期许和目标，有助于确立用户体验各方面战略的制定。然而回答这些看似简单的问题却不如说起来那么容易。<br />
<br />
<strong>范围层(scope)——功能规格和内容说明</strong><br />
带着&#8220;我们想要什么&#8221;、&#8220;我们的用户想要什么的&#8221;的明确认识，我们就能弄清楚如何去满足所有这些战略的目标。当你把用户需求和网站目标转变成网站应该提供给用户什么样的内容和功能时，战略就变成了范围。<br />
<br />
<strong>结构层(structure)——交互设计与信息架构</strong><br />
在收集完用户需求并将其排列好优先级别之后，我们对于最终展品将会包括什么特性已经有了清楚的图像。然而，这些需求并没有说明如何将这些分散的片段组成一个整体。这就是范围层的上面一层：为网站创建一个概念结构。<br />
<br />
<strong>框架层(skeleton)——界面设计、导航设计和信息设计<br />
</strong>在充满概念的结构层中开始形成了大量的需求，这些需求都是来自我们的战略目标的需求。在框架层，我们要更进一步地提炼这些结构，确定很详细的界面外观、导航和信息设计，这能让美色的结构变得更实在。<br />
<br />
<strong>表现层(surface)——视觉设计</strong><br />
在这个五层木星的顶端，我们把注意力转移到网站用户会先注意到的那些方面：视觉设计，这里，内容、功能和美学汇集到一起来产生一个最终设计，这将满足其他四个层面的所有目标。</p>
<img alt="" src="http://www.blogjava.net/images/blogjava_net/rain1102/39818/o_elements.jpg" border="0" /><img src ="http://www.blogjava.net/rain1102/aggbug/277897.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/rain1102/" target="_blank">周锐</a> 2009-05-25 21:11 <a href="http://www.blogjava.net/rain1102/archive/2009/05/25/277897.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>PDCA循环【转载】</title><link>http://www.blogjava.net/rain1102/archive/2009/03/09/258676.html</link><dc:creator>周锐</dc:creator><author>周锐</author><pubDate>Mon, 09 Mar 2009 13:37:00 GMT</pubDate><guid>http://www.blogjava.net/rain1102/archive/2009/03/09/258676.html</guid><wfw:comment>http://www.blogjava.net/rain1102/comments/258676.html</wfw:comment><comments>http://www.blogjava.net/rain1102/archive/2009/03/09/258676.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/rain1102/comments/commentRss/258676.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/rain1102/services/trackbacks/258676.html</trackback:ping><description><![CDATA[<div class="postText">PDCA循环的概念最早是由美国<a title="质量管理,质量管理" href="http://mie168.com/manage/quality/management.htm" target="_blank">质量管理</a>专家戴明提出来的，所以又称为&#8220;戴明环&#8221;。PDCA四个英文字母及其在PDCA循环中所代表的含义如下：<br />
&nbsp;&nbsp;1、 P（Plan）--计划，确定方针和<a title="组织,目标,组织,目标" href="http://mie168.com/manage/zuzhi-mubiao.htm" target="_blank">目标</a>，确定活动计划；<br />
&nbsp;&nbsp;2、 D（Do）--执行，实地去做，实现计划中的内容；<br />
&nbsp;&nbsp;3、 C（Check）--检查，总结执行计划的结果，注意效果，找出问题；<br />
&nbsp;&nbsp;4、 A（Action）--行动，对总结检查的结果进行处理，成功的经验加以肯定并适当推广、标准化；失败的教训加以总结，以免重现，未解决的问题放到下一个PDCA循环。
<p>PDCA循环实际上是有效进行任何一项工作的合乎逻辑的工作程序。在质量管理中，PDCA循环得到了广泛的应用，并取得了很好的效果，因此有人称PDCA循环是质量管理的基本方法。之所以将其称之为PDCA循环，是因为这四个过程不是运行一次就完结，而是要周而复始地进行。一个循环完了，解决了一部分的问题，可能还有其它问题尚未解决，或者又出现了新的问题，再进行下一次循环，其基本模型如下图1所示。</p>
<p><img alt="" src="http://www.globrand.com/UploadFile//2006418182554843.JPG" border="0" /></p>
<p>PDCA循环有如下三个特点：</p>
<p>1、大环带小环。如果把整个企业的工作作为一个大的PDCA循环，那么各个部门、小组还有各自小的PDCA循环，就像一个行星轮系一样，大环带动小环，一级带一级，有机地构成一个运转的体系。<br />
&nbsp;&nbsp; <br />
&nbsp;&nbsp;<img alt="" src="http://www.globrand.com/UploadFile//2006418182555830.JPG" border="0" /></p>
<p>2、阶梯式上升。PDCA循环不是在同一水平上循环，每循环一次，就解决一部分问题，取得一部分成果，工作就前进一步，水平就提高一步。到了下一次循环，又有了新的目标和内容，更上一层楼。下面图2表示了这个阶梯式上升的过程。</p>
<p>3、科学管理方法的综合应用。PDCA循环应用以QC七种工具为主的统计处理方法以及工业工程（IE）中工作研究的方法，作为进行工作和发现、解决问题的工具。PDCA循环的四个阶段又可细分为八个步骤，每个步骤的具体内容和所用的方法如下表3所述。<br />
&nbsp;&nbsp; 表3 PDCA循环的步骤和方法</p>
<p><img style="width: 589px; height: 262px" height="262" alt="" src="http://www.globrand.com/UploadFile//2006418182556468.JPG" width="589" border="0" /></p>
</div><img src ="http://www.blogjava.net/rain1102/aggbug/258676.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/rain1102/" target="_blank">周锐</a> 2009-03-09 21:37 <a href="http://www.blogjava.net/rain1102/archive/2009/03/09/258676.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>我和敏捷团队的五个约定[转载]</title><link>http://www.blogjava.net/rain1102/archive/2009/03/04/257840.html</link><dc:creator>周锐</dc:creator><author>周锐</author><pubDate>Wed, 04 Mar 2009 09:36:00 GMT</pubDate><guid>http://www.blogjava.net/rain1102/archive/2009/03/04/257840.html</guid><wfw:comment>http://www.blogjava.net/rain1102/comments/257840.html</wfw:comment><comments>http://www.blogjava.net/rain1102/archive/2009/03/04/257840.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/rain1102/comments/commentRss/257840.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/rain1102/services/trackbacks/257840.html</trackback:ping><description><![CDATA[<p class="info">作者 <strong>覃其慧</strong> 发布于 2009年3月2日 上午12时30分 <br />
</p>
<p>我——作为一名测试人员——有一个与众不同的习惯：每当要加入一个新项目的时候，我总会找到项目中的同伴，真诚而亲切地说：&#8220;为了更好地合作，我有5个约定，希望大家能尽量遵守&#8221;。</p>
<p><strong>约定1. 业务分析师们，我们其实是同一个角色的两种面孔，请叫上我们参加客户需求会议</strong></p>
<p>我们的团队需要让客户频繁的得到可用的软件，客户的不断反馈会给软件的未来做出最正确的方向指引。</p>
<p>如果我们交付的软件有很多质量的问题，存在大量的缺陷，客户会被这些缺陷的奇怪行为干扰，没有办法把注意力放在软件本身的价值是否符合他们的真正需求上， 不能给出最有价值的反馈。所以，我们只有频繁的做测试，在每次交付之前都把质量问题找出来告诉我们的团队，问题才能及时的得到改正。</p>
<p>而我坚信&#8220;prevention is better than cure&#8221;（预防胜于治疗），我会要把工作的重点放在预防缺陷上，这样可以节省Dev们很多修复缺陷的时间与精力。</p>
<p>为了达到这个目的，我需要跟你一起参加客户需求会议，尽早的了解客户需求与使用软件的惯常行为。那么在你完成需求的验收条件的定义的时候，我也基本完成了测试用例的准备。</p>
<p>我们可以赶在开发人员们写代码之前就告诉他们我要测什么，让他们减少因为过于乐观而漏掉的一些重要的有破坏性的情况，减少缺陷的发生。这是我测试的一项重要任务。</p>
<p>如果你们在大部分需求都整理好了再交给我们，我会浪费掉等待的时间。更重要的是，开发好的软件里面已经有很多本来可以不存在的缺陷在里面了，开发人员们可能需要加班加点来保证在项目最终交付时间之前把它们改好。这样很容易产生新的缺陷的。</p>
<p>所以，请让我尽早了解需求，请不要让我到项目后期才能开始测试。</p>
<p><strong>约定2. 开发人员们，虽然你们是编写自动化测试的专家，但请听听我们意见</strong></p>
<p>我知道，对于你们，自动化测试不过是利用junit, rspec, selenium，watir，uiautomation等等写出的&#8220;另一段程序&#8221;而已。而对于80%的QA来说，编写自动化测试并不是一件简单的事情。</p>
<p>不过我仍然相信，有测试人员介入的自动化测试更有价值。</p>
<p>你们用单元测试，集成测试来保证代码的质量。然而你们的这些日常测试离代码更近，离最终用户还点远。很多测试都不是在测软件功能。</p>
<p>你们可以把功能测试写的又快又多，而我们可以指出什么功能测试最有必要加到自动化测试中。</p>
<p>你们平时大部分精力都在编码上，没有太多时间去查都有什么缺陷。而我们可以指出什么地方缺陷可能会出现的比较频繁，建议在这些脆弱的地方加自动化测试。</p>
<p>所以请听听我们的意见，我们可以给你们提供这些信息。</p>
<p><strong>约定3. 项目经理们，请不要要求我们测试软件的所有路径 </strong></p>
<p>软件测试是一个永无止尽的任务。基本上没有什么软件简单到我们能够尝试完它的每一个可能的路径的。就连一个看似简单的微软计算器都有无穷尽的路径，无止尽的输入，更何况比这个更复杂的商用软件。</p>
<p>如果你们担心没有尝试过全部的路径不可靠，疑惑我们怎么敢说这个软件质量是好的还是坏，都有什么风险。请你们先注意，我们是跟业务分析师一样，都了解软件的价值的。价值可以帮我们做出判断，什么时候可以停止测试并对客户说我们的软件已经满足您的要求了，请放心使用。</p>
<p>因为我们了解价值，我们可以肯定的说哪些软件的使用方式是至关重要的，哪些是不太可能出现的。我们会在全面测试了软件以后，把主要精力放在价值高的功能点上。合理的利用项目有限的时间。</p>
<p>因为我们了解价值，我们可以正确的把发现的问题分类。我们可以帮助dev们把精力放在重要的缺陷上，避免把时间放在对于客户微不足道却不得不花费大量精力才能修正的问题上。</p>
<p>所以，请不要要求我们无止尽的测试一个软件。我们了解价值，请相信我们的判断。</p>
<p><strong>约定4. 迭代经理们，如果对于交付风险有任何疑问，请来询问我 </strong></p>
<p>BA和Dev们都是关注一个软件在什么情况是可以良好的工作。而我们除了验证这些情况以外，大量的时候都用在寻找什么样的情况软件不能正常的运行。所以除 了针对定义好的软件行为进行测试，我们还会做很多探索性测试。我们通常可以通过这样的测试发现一些没有定义的、不曾预期的行为。这些行为往往将会构成软件 交付的风险。</p>
<p>我们会告诉你们现在都发生了什么问题，分别分布在哪里。</p>
<p>我们会告诉你们，在什么情况下软件可能会有异常行为，是不是会牵连到其他的部分，是否可以绕过去。</p>
<p>我们会告诉你们，哪些部分功能比较不稳定，需要更多的留意。</p>
<p><strong>约定5. 测试人员们，那些敏捷实践对于我们也是有用的。 </strong></p>
<p>结对不是dev们的专利。我不希望总见到你们独自坐在自己的位置上冥思苦想。走出去，跟其他队友多多交流！</p>
<p>多跟测试队友交流，pair看看设计的测试用例是不是够全面，独自一个人想到的未必足够好。他们会给你诚恳的意见的。对他们，也请一样认真对待。</p>
<p>如果你发现开发人员们做出的架构决定使测试工作变得更困难。那么请大声地告诉他们，design for testability（提高你们设计的可测性）。</p>
<p>如果你发现业务分析师写的需求无法验证，定义的客户行为不够具体，一个用户故事中包含太多了功能点，等等，那么也请大声地告诉他，INVEST（独立，可协商，价值，可估算，短小，可测）。</p>
<p>也请你们多跟开发人员结对写自动化测试，既可以帮助你们学习怎样更好的编写自动化测试，也能帮助开发人员们结对更多的了解用户行为。</p>
<p>这就是我的五个约定，它们是我在团队中顺利展开工作的基础。</p><img src ="http://www.blogjava.net/rain1102/aggbug/257840.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/rain1102/" target="_blank">周锐</a> 2009-03-04 17:36 <a href="http://www.blogjava.net/rain1102/archive/2009/03/04/257840.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>The tao of programming</title><link>http://www.blogjava.net/rain1102/archive/2009/02/11/254310.html</link><dc:creator>周锐</dc:creator><author>周锐</author><pubDate>Wed, 11 Feb 2009 13:40:00 GMT</pubDate><guid>http://www.blogjava.net/rain1102/archive/2009/02/11/254310.html</guid><wfw:comment>http://www.blogjava.net/rain1102/comments/254310.html</wfw:comment><comments>http://www.blogjava.net/rain1102/archive/2009/02/11/254310.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/rain1102/comments/commentRss/254310.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/rain1102/services/trackbacks/254310.html</trackback:ping><description><![CDATA[<p>1&gt; When you have learned to snatch the error code from the trap frame, it will be time for you to leave. <br />
2&gt; After three days without programming, life become meaningless.<br />
3&gt; When the program is being tested, it is too late to make design changes.<br />
4&gt; A well-written program is its own heaven; a poorly-written program its own hell.<br />
5&gt; Though a program be but ghree lines long, someday it will have to be maintained.<br />
6&gt; Let the programmers be many and the managers few-then all will be productive.<br />
7&gt; You can demonstrate a program for an executive, but you can't make him computer literate.<br />
8&gt; Without the wind, the grass does not move, wihtout software, hardware is useless.</p>
<p><br />
&nbsp;</p><img src ="http://www.blogjava.net/rain1102/aggbug/254310.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/rain1102/" target="_blank">周锐</a> 2009-02-11 21:40 <a href="http://www.blogjava.net/rain1102/archive/2009/02/11/254310.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>读人件</title><link>http://www.blogjava.net/rain1102/archive/2009/01/23/252434.html</link><dc:creator>周锐</dc:creator><author>周锐</author><pubDate>Fri, 23 Jan 2009 02:18:00 GMT</pubDate><guid>http://www.blogjava.net/rain1102/archive/2009/01/23/252434.html</guid><wfw:comment>http://www.blogjava.net/rain1102/comments/252434.html</wfw:comment><comments>http://www.blogjava.net/rain1102/archive/2009/01/23/252434.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/rain1102/comments/commentRss/252434.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/rain1102/services/trackbacks/252434.html</trackback:ping><description><![CDATA[<p>早就听闻《人件》和《人月神话》共同被誉为软件界图书中的&#8220;两朵最鲜艳的奇葩&#8221;。人们认为：《人月神话》关注&#8220;软件开发&#8221;本身，而《人件》则关注软件开发中的&#8220;人&#8221;。处于好奇原因，前几天从图书馆借了本第二版回来随便翻了翻，竟然得以持续，花了几天的业余时间，快速的看了一遍，体会颇深，即记于此。<br />
由于译者离国时间太久原因，翻译的不是太能让人读懂，如果中文不是太差的话，应该还能读下去。<br />
书中的一些思想和观点让我感觉到很震撼与吃惊，这也是我为什么能很快的读完全书的原因所在，对于人才和团队的建立，培养和管理，书中可谓是详解独到，IT应以人为本，其他都是其次，它解释了脑力劳动的独特之处，使用大量的制造业管理模式是显然不适合的，更会产生负面影响。两位笔者以风趣而尖锐的笔调，直击普遍存在的管理弊端。从适合脑力工作者的工作环境，到群体政治，再到体贴员工，培养出胶冻的团队，社区的形成等等。<br />
目前，多数管理者很少体会以及了解脑力劳动者的特殊需求，认为任何提升脑力劳动者生产力的要求都是公司的支出，而非投资。空间的压抑，工作场所的噪声以及公司的任意奖励政策和措施和防范性管理、官僚体系、物理隔离、时间分隔、产品质量要求降低、假的截至日期、私党的控制等等都扼杀了自己的团队，降低了团队的生产力以及创造力。作者还分析了CMM以及过程改进，强调过程改进是好的，但过程改进程序未必是好的。下面从书中的六个部分开始分析：<br />
<br />
第一部分：管理人力资源<br />
作者强调：管理者的工作不是命令人去工作，而是创造条件让人自己想去工作。作者使用了做吉士汉堡，卖吉士汉堡来嘲讽了那些按照工厂模式来分配指派程序员工作，做一些所谓的人员储备，把人看成可换的零件，只会打击程序员的士气和创造性。<br />
管理要以人为本！<br />
<br />
第二部分：办公环境<br />
作者强调：避免让脑力工作者处在难以聚精会神的工作环境下工作，管理者需要提升的是程序员正常工作时间的&#8220;质&#8221;，而非延长程序员工作时间的&#8220;量&#8221;。那样只会使程序员放弃自己的理想与质量，影响程序员的生理健康以及家庭和谐，从而导致优秀员工的流失。<br />
由于公司管理层的片面人为以及错误的思想，导致脑力劳动者全部拥挤在一个嘈杂混乱的办公场所以及公司的那些家具警察的来回走动，从而使脑力劳动者难以进入顺流状态。作者在本部分中多次建议管理者要多考虑工作环境问题，为脑力劳动者提供一个安静、宽敞、隐私的工作环境，这样才能够创造一个有创造性、有活力的高生产力的团队。程序设计师之间存在 10 比 1 的生产力差异&#8230;同样，软件公司间也存在着 10 比 1 的生产力差异」，而你期待的团队生产力为何？<br />
<br />
第三部分：适当人选<br />
作者强调：就任何工作的最终成果而言，由&#8220;谁&#8221;来做总比&#8220;如何&#8221;去做的影响的还要大。我们不怕问题，只怕处理问题的人。作者道出的成功的重点公式：<br />
&nbsp;&nbsp;&nbsp;&nbsp;找到适合的人<br />
&nbsp;&nbsp;&nbsp;&nbsp;让他们很高兴在这里而不想走<br />
&nbsp;&nbsp;&nbsp;&nbsp;放手让他们任意发挥<br />
从上面的公式分析如何找到一个合适的人选，以及如何留下人才，让他们很好的发挥各自的才能，作者还分析了员工为什么会离开，以及员工流动的明显成本，以及一些隐形的成本。<br />
<br />
第四部分：生产力不断增长的团队<br />
作者首先强调：整体大于部分总和，以及什么是胶冻团队，团队与个人之间的关系。随着项目的日益庞大与复杂，企业的成功与否主要看你的团队成功与否，管理层要多注意团队的培养，防止出现团队自杀现象，经理更应该体贴员工，创造团队成员之间的交流与合作机会，提高团队成员之间的默契感和协作能力，使团队形成一种强大的亲和力。<br />
<br />
第五部分：应该开心地在这里工作<br />
作者强调如何创造一种愉快的工作氛围，并列出了一些措施：<br />
&nbsp;&nbsp;&nbsp;&nbsp;前导项目<br />
&nbsp;&nbsp;&nbsp;&nbsp;竞赛<br />
&nbsp;&nbsp;&nbsp;&nbsp;头脑风暴<br />
&nbsp;&nbsp;&nbsp;&nbsp;培训、旅游、会议、庆祝和休息<br />
最后作者鼓励你成为自由人，让自我期许高于管理者对你的期许，唤醒大家对价值的再造。<br />
<br />
第六部分：《人件》续集<br />
本部分为两位作者在20年后为第一版所做的补充，再次分析加班的种种弊端，以及竞争的正反面，关于一些过程改进的谬论和CMM的反省，强调过程的成熟使在降低风险，但是，如果能让你成熟度级别降低的项目，往往会是最有价值的项目。本部分还讲了如何去估算评估人力资本，公司中阶层的组织学习，并谈及社区的形成。 </p><img src ="http://www.blogjava.net/rain1102/aggbug/252434.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/rain1102/" target="_blank">周锐</a> 2009-01-23 10:18 <a href="http://www.blogjava.net/rain1102/archive/2009/01/23/252434.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>做吉士汉堡，卖吉士汉堡－读人件</title><link>http://www.blogjava.net/rain1102/archive/2009/01/17/251732.html</link><dc:creator>周锐</dc:creator><author>周锐</author><pubDate>Sat, 17 Jan 2009 14:13:00 GMT</pubDate><guid>http://www.blogjava.net/rain1102/archive/2009/01/17/251732.html</guid><wfw:comment>http://www.blogjava.net/rain1102/comments/251732.html</wfw:comment><comments>http://www.blogjava.net/rain1102/archive/2009/01/17/251732.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/rain1102/comments/commentRss/251732.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/rain1102/services/trackbacks/251732.html</trackback:ping><description><![CDATA[<strong>错误限额</strong><br />
对于大多数脑力劳动者来说，偶尔犯一个错误是自然的，也是他们工作的一个健康组成部分，但我们却持有这样的态度：工作中的差错与罪过之间几乎有天生的联系，这是一种特别需要努力去改变的态度。鼓励人们犯一些错误。你有时候可以询问你的下属走过怎样的死胡同，并且确实让他们理解&#8220;没有&#8221;并不是最好的答案。当人们犯错误时，应该祝贺他们－那是他们所得到报偿的一部分。<br />
<br />
<strong>管理：莽汉定义<br />
</strong>管理方法最悲哀之处是它几乎总是多余的，你很少需要严厉的措施让你的人员一直处于工作状态，他们大多数热爱自己的工作。你甚至应该有时候采取措施让他们少做一些工作，从而做更有意义的工作。<br />
<br />
<strong>人员储备<br />
</strong>对于那个盲目的从生产领域采纳一种管理模式的经理而言，每个人的工作特性是连续不断的烦恼。另一方面，天生的（管理）人的经理意识到独特性对项目的亲和力重要而有效。独特性是要培养的东西。<br />
<br />
<strong>一个稳定状态项目就是死胡同<br />
</strong>催化剂是重要的，因为项目总是处于一种变化的状态之中。能够帮组一个项目凝聚起来的人比得上两个只能做工作的人。<br />
<br />
<strong>我们还没有时间来考虑这项工作，只有时间来做这项工作<br />
</strong>随着风险的增加，对方法深思熟虑更加重要。如果真的要做巨大的工作时，我们必须学会花更少的时间工作和花更多的时间思考工作本身。工作越艰巨，团队成员学会良好互动并以此为乐就变得更加重要。一个在不可能的给定时间内要完成的项目，恰恰需要抽出时间来频繁地召开头脑风暴会，甚至组织一次项目组聚餐或者其他诸如此类的事情，以帮组个人融入高效的整体。<br />
（计划，研究新方法，培训，阅读，评估，预算，安排进度以及人事安排等等综合活动。）<img src ="http://www.blogjava.net/rain1102/aggbug/251732.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/rain1102/" target="_blank">周锐</a> 2009-01-17 22:13 <a href="http://www.blogjava.net/rain1102/archive/2009/01/17/251732.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>在今天的某个地方，一个项目正在失败－读人件</title><link>http://www.blogjava.net/rain1102/archive/2009/01/17/251730.html</link><dc:creator>周锐</dc:creator><author>周锐</author><pubDate>Sat, 17 Jan 2009 13:26:00 GMT</pubDate><guid>http://www.blogjava.net/rain1102/archive/2009/01/17/251730.html</guid><wfw:comment>http://www.blogjava.net/rain1102/comments/251730.html</wfw:comment><comments>http://www.blogjava.net/rain1102/archive/2009/01/17/251730.html#Feedback</comments><slash:comments>1</slash:comments><wfw:commentRss>http://www.blogjava.net/rain1102/comments/commentRss/251730.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/rain1102/services/trackbacks/251730.html</trackback:ping><description><![CDATA[<p>解释一个项目失败的原因，不仅仅是技术问题。<br />
<strong><br />
问题的实质<br />
</strong>本质上，我们工作中的主要问题，与其说是技术问题，不如说是社会学问题。<br />
在很多项目中，人员方面遇到的难题往往比技术方面遇到的难题更多。然而很少有人用这样的思想去知道工作。他们做管理工作时，好像技术是他们关心的主要事情，他们把自己的时间花在解决最费解的额是最有趣的难题上，这些难题本来是他们下属必须解决的，却仿佛是他们自己做这些工作而不是去管理它。而他们的职责中最应做的面向人的方面，常常被赋予最低的优先级。<br />
<br />
<strong>高科技幻觉</strong><br />
我们倾向于集中精力去做技术方面，而不是人际关系方面的工作的主要原因，不是因为它更重要，而是因为它更容易做。<br />
如果你发现自己关注的是技术而不是社会方面的问题，你就相当于在一条黑暗的街上丢失了钥匙，却到邻近的另一条街上去寻找。因为&#8220;这条街上的灯比那条街上的灯要亮一些&#8221;。</p><img src ="http://www.blogjava.net/rain1102/aggbug/251730.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/rain1102/" target="_blank">周锐</a> 2009-01-17 21:26 <a href="http://www.blogjava.net/rain1102/archive/2009/01/17/251730.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>面试游击－摘自JOEL ON SOFTWARE</title><link>http://www.blogjava.net/rain1102/archive/2009/01/14/251346.html</link><dc:creator>周锐</dc:creator><author>周锐</author><pubDate>Wed, 14 Jan 2009 13:10:00 GMT</pubDate><guid>http://www.blogjava.net/rain1102/archive/2009/01/14/251346.html</guid><wfw:comment>http://www.blogjava.net/rain1102/comments/251346.html</wfw:comment><comments>http://www.blogjava.net/rain1102/archive/2009/01/14/251346.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/rain1102/comments/commentRss/251346.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/rain1102/services/trackbacks/251346.html</trackback:ping><description><![CDATA[<strong>你如何知道是否去聘用某个人？</strong><br />
1. 机敏<br />
2. 成事<br />
很机敏但不能成事的人通常拥有博士学位并在大型公司里面供职，在那里没有人听他们的，因为他们根本是不切实际的。他们更擅长于从事对某个问题的学术思考，而不是去做一些实际的事情。这种人与众不同的地方是他们喜欢指出两个引起广泛分歧的概念之间所具有的理论相似性。<br />
能成事但不够聪明的人会做愚蠢的事情，就好像做事不动脑子一样，这样就要其他人在他后面为他擦屁股，可见，这样的人对公司一点也不可靠。<br />
<br />
<strong>面试要问些什么呢？</strong><br />
1. 介绍<br />
2. 询问应聘人员最近从事的项目情况<br />
3. 问一些不可能回答上来的问题<br />
4. 程序设计问题<br />
5. 问他自己是否对自己满意吗<br />
6. 让他提问一些问题<br />
<br />
<strong>不问什么？<br />
</strong>避免提问非法问题！<img src ="http://www.blogjava.net/rain1102/aggbug/251346.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/rain1102/" target="_blank">周锐</a> 2009-01-14 21:10 <a href="http://www.blogjava.net/rain1102/archive/2009/01/14/251346.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>读JOEL说软件</title><link>http://www.blogjava.net/rain1102/archive/2008/12/19/247266.html</link><dc:creator>周锐</dc:creator><author>周锐</author><pubDate>Fri, 19 Dec 2008 01:14:00 GMT</pubDate><guid>http://www.blogjava.net/rain1102/archive/2008/12/19/247266.html</guid><wfw:comment>http://www.blogjava.net/rain1102/comments/247266.html</wfw:comment><comments>http://www.blogjava.net/rain1102/archive/2008/12/19/247266.html#Feedback</comments><slash:comments>1</slash:comments><wfw:commentRss>http://www.blogjava.net/rain1102/comments/commentRss/247266.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/rain1102/services/trackbacks/247266.html</trackback:ping><description><![CDATA[&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<strong>第一部分 位与字节：编程实践点滴<br />
</strong><br />
一 语言的选择 /2<br />
<br />
二 深入底层 /4<br />
<br />
三 JOEL测试：改进代码的12个步骤 /14<br />
&nbsp;&nbsp;&nbsp;&nbsp; 1. 使用源控制机制吗？<br />
&nbsp;&nbsp;&nbsp;&nbsp; 2. 能一步完成连编吗？<br />
&nbsp;&nbsp;&nbsp;&nbsp; 3. 每天都连编吗？<br />
&nbsp;&nbsp;&nbsp;&nbsp; 4. 有故障信息数据库吗？<br />
&nbsp;&nbsp;&nbsp;&nbsp; 5. 在编写新代码之前修复故障吗？<br />
&nbsp;&nbsp;&nbsp;&nbsp; 6. 有最新的进度表吗？<br />
&nbsp;&nbsp;&nbsp;&nbsp; 7. 有规格说明书吗？<br />
&nbsp;&nbsp;&nbsp;&nbsp; 8. 程序员拥有安静的工作环境吗？<br />
&nbsp;&nbsp;&nbsp;&nbsp; 9.&nbsp;你用到了你资金能力内可买到的最好工具吗？<br />
&nbsp;&nbsp;&nbsp;&nbsp;10. 有测试人员吗？<br />
&nbsp;&nbsp;&nbsp;&nbsp;11. 新聘人员在试用期写代码吗？<br />
&nbsp;&nbsp;&nbsp;&nbsp;12. 进行走廊可用性测试吗？<br />
<br />
四 每一位软件开发人员必须、绝对要至少具备UNICODE与字符集知识(没有任何例外!) /27<br />
<br />
五 轻松写就功能规格说明书 第1节：为什么烦心? /38<br />
<br />
六 轻松写就功能规格说明书 第2节：什么是规格说明书? /44<br />
&nbsp;&nbsp;&nbsp;&nbsp;1. 事先声明<br />
&nbsp;&nbsp;&nbsp;&nbsp;2. 作者<br />
&nbsp;&nbsp;&nbsp;&nbsp;3. 情节<br />
&nbsp;&nbsp;&nbsp;&nbsp;4. 非构建目标<br />
&nbsp;&nbsp;&nbsp;&nbsp;5. 概观<br />
&nbsp;&nbsp;&nbsp;&nbsp;6. 细节，细节，细节<br />
&nbsp;&nbsp;&nbsp;&nbsp;7. 未尽事宜<br />
&nbsp;&nbsp;&nbsp;&nbsp;8. 旁注<br />
&nbsp;&nbsp;&nbsp;&nbsp;9. 规格说明书需要保持时时更新的状态<br />
<br />
七 轻松写就功能规格说明书 第3节：但是&#8230;&#8230;如何? /54<br />
<br />
八 轻松写就功能规格说明书 第4节：技巧 /58<br />
<br />
九 轻松制订软件进度表 /65<br />
<br />
十 每日连编是朋友 /75<br />
<br />
十一 难伺候的故障修复 /81<br />
<br />
十二 软件开发中的5个世界 /87<br />
<br />
十三 稿纸原型开发 /94<br />
<br />
十四 不要被太空架构师所吓倒 /96<br />
<br />
十五 开火与运动 /100<br />
<br />
十六 人员技能 /一104<br />
<br />
十七 源于计算机学科的三个错误思想 /109<br />
<br />
十八 二元文化 /4<br />
<br />
十九 自动获取用户故障报表 /120<br />
<br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<strong>&nbsp;第二部分 开发人员的管理<br />
</strong><br />
二十 面试游击指南 /132<br />
<br />
二十一 重金激励害多利少 /145<br />
<br />
二十二 不配备测试人员的五个首要(错误)原因 /149<br />
<br />
二十三 任务换人有害无益 /156<br />
<br />
二十四 绝不去做的事情，第一部 /160<br />
<br />
二十五 冰川下的秘密 /165<br />
<br />
二十六 漏洞抽象定律 /172<br />
<br />
二十七 程序设计界的Lord Palmerston /178<br />
<br />
二十八 评测 /185<br />
<br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<strong>第三部分 Joel对常态问题的遐想<br />
</strong><br />
二十九 Rick Chapman解读愚昧 /188<br />
<br />
三十 在这个国家狗是干什么的? /193<br />
<br />
三十一 作为哼哈二将，只管去做事 /198<br />
<br />
三十二 两个故事 /204<br />
<br />
三十三 巨无霸麦当劳与天才厨师Jamie Olivei /209<br />
<br />
三十四 没有什么像IT看起来那么简单 /214<br />
<br />
三十五 提防非自主开发综合症 /218<br />
<br />
三十六 策略I：BEN＆JERRY公司与AMAZON /222<br />
<br />
三十七 策略Ⅱ：鸡与蛋问题 /230<br />
<br />
三十八 策略III：让我回去! /237<br />
<br />
三十九 策略IV：大件与80／20神话 /242<br />
<br />
四十 策略V：公开源代码的经济因素 /246<br />
<br />
<br />
四十一 墨菲法则肆掠的礼拜 /254<br />
<br />
四十二 微软公司是如何败北API之战的 /258<br />
<br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<strong>第四部分 对．NET稍多的评说<br />
</strong><br />
四十三 微软精神失常了 /276<br />
<br />
四十四 我们的．NET对策 /282<br />
<br />
四十五 请问，我可以使用连接程序吗 /286<br />
<br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<strong>第五部分 附录<br />
</strong><br />
附录A 很好的问题 /290<br /><img src ="http://www.blogjava.net/rain1102/aggbug/247266.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/rain1102/" target="_blank">周锐</a> 2008-12-19 09:14 <a href="http://www.blogjava.net/rain1102/archive/2008/12/19/247266.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>好的架构师都是善良的独裁者[转载]</title><link>http://www.blogjava.net/rain1102/archive/2008/12/17/246897.html</link><dc:creator>周锐</dc:creator><author>周锐</author><pubDate>Wed, 17 Dec 2008 08:35:00 GMT</pubDate><guid>http://www.blogjava.net/rain1102/archive/2008/12/17/246897.html</guid><wfw:comment>http://www.blogjava.net/rain1102/comments/246897.html</wfw:comment><comments>http://www.blogjava.net/rain1102/archive/2008/12/17/246897.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/rain1102/comments/commentRss/246897.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/rain1102/services/trackbacks/246897.html</trackback:ping><description><![CDATA[<p>原文地址: http://tech.it168.com/a2008/1209/259/000000259786.shtml<br />
对于任何一个软件开发人员来说，架构师都是一个令人向往的角色。就连世界首富比尔盖茨在2000年卸任公司CEO的同时，也担任了微软公司的荣誉角色&#8220;首席软件架构师&#8221;，可见&#8220;架构师&#8221;这一称谓的吸引力。架构师是公司的&#8220;金领&#8221;，有着非常高的收入，很少需要考虑生存的问题，从而有更多的精力思考关键技术问题，形成&#8220;强者愈强&#8221;的良性循环。部分优秀的开发人员在工作了一定时间后，就要开始考虑自己的未来到底向哪个方向发展。如果开发人员的沟通能力强过技术能力，在补充一定的项目管理知识后，可以向技术管理的方向转型。如果其对技术一直很感兴趣，而沟通能力也不弱，则可以试着进一步加强技术修养，以期向架构师的方向发展，最终&#8220;修成正果&#8221;。 </p>
<p>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 那么，到底什么是架构师呢？所谓的架构师，应该是一个技术企业的最高技术决策者。他主要负责公司软件产品或软件项目的技术路线与技术框架的制订。好的架构师都是善良的独裁者，具有很强的技术、良好的写作能力、良好的口头表达能力，能够在各个层次进行沟通。从开发人员到架构师的成长应该是阶梯式的，一般来讲开发人员在刚刚开始工作时只能开发简单的独立软件模块，慢慢的随着经验的增长，他开始接触一些相互之间有信息传递的模块，而后来，他会发现自己接到的开发任务已经不是一个独立的单体，这些任务由一些专门的软件部分组成，可能包含数据库，工作流引擎，消息服务等等各种功能模块，可能分布在不同的服务器上，所有的部分协同起来，完成软件功能。而这时候，体系结构的好坏将直接决定了系统的性能和可扩展性，而就在这时候，这名优秀的开发人员也开始思考架构师应该思考的问题了，或者说，他向成长为架构师的道路迈出了一大步。</p>
<p>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 什么是架构师最具价值的技能呢？就是要了解不同的知识，做一个&#8220;杂家&#8221;或者说&#8220;博学家&#8221;。当然，如果你的数据库技术非常棒，或者你在工作流引擎方面具有不可超越的专家知识，那也是很不错的。好的架构师有好多都是从专家成长过来的。但是，这不是架构师应该做的事情，架构师应该做的是了解所有的东西，既了解技术的宏观面，又了解技术的细节。真正的架构师不仅仅要了解软件，也要了解硬件，在关键的部位使用合适的硬件来取代软件，可以成倍甚至成百倍的提高整个系统的效率。下面我将会以互联网行业对的架构师的要求为例，向大家讲解作为架构师应该具备的知识。</p>
<p>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 互联网行业是当前最激动人心的行业之一，很多的创新都来自于这个行业，而每一个大型的网站如Google，Yahoo，Myspace等都需要解决一个非常复杂的问题，就是网站的分布式向外扩展(Scale Out)的问题。解决这个问题，需要最优秀的架构师对业务进行剖析，利用软硬件将网站进行重构，甚至根据业务研发相应的分布式技术，解决网站复杂的分布式计算的问题。</p>
<p>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 如果你想在这个行业中成为一名架构师的话，需要至少掌握网络知识，硬件，软件，网站优化等方方面面的知识：<br />
网络知识<br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 当前的软件已经绝对不是那种仅仅跑在一台单机上的孤立应用了。不仅仅是在互联网行业，任何一个行业的软件，都要求其具有网络功能。因此，网络知识是架构师必备的知识。我们所说的网络知识，不仅仅包括TCP/IP，http等互联网行业常用的软件协议，也包括网络规划，甚至更具体的说，根据网站应用所处的地理环境进行网络规划。比如人们常说：&#8220;这世界上最远的距离不是生与死的距离，而是电信到网通的距离&#8221;（笑）如果应用是建立在中国的，就要考虑电信用户和网通用户访问网站的速度应该都比较快才可以。这时候的解决方案可能有多种，比如采用CDN（Content Delivery Network内容分发网络）使得网站的内容发布到离用户最近的服务器，又可以采用把服务器放在一些所谓的双线机房中，甚至将几种方案结合起来使用。这些都统统归到网络知识中。做为公司的架构师，要对这些知识都有所了解，才有助于在遇到问题时找到最佳答案。<br />
硬件知识<br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 了解硬件的极限，是架构师的基本功。我见过一些人，他们的眼中软件硬件都是没有极限的，需要资源就申请，系统性能下降了就买更高级的设备。然而，硬件的性能有很大一部分取决于I/O设备。而这些I/O设备依靠的都是机械物理运动，这种运动是有极限的。因此当资源访问量增大到一定的程度时，这种物理运动将成为瓶颈。比如说，在开发网站的过程中，记录访客的状态是一件很重要的事情，一般来说可以使用HttpSession来记录。而HttpSession的存储问题将是一个很大的挑战，尤其是多机共享Session时，将HttpSession存成文件并通过多机共享或网络备份的方式来解决分布式的问题是常用的方案，然而，架构师必须考虑到这种方案是有I/O极限限制的，很难扩展到超过一定规模的大型网络。同时，架构师应该了解目前最近的硬件发展是否对软件系统会造成一定的影响，比如在多核的条件下是否对软件编程有新的要求，是否会对运行在虚拟机和非虚拟机上的程序有影响等等。<br />
软件知识<br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 软件知识所包含的范围就更加广泛了。对于互联网行业来讲，架构师要了解操作系统，数据库，应用服务器等各方面的知识。比如说，如果网站使用的操作系统是Linux，就要了解这个Linux版本的性能与局限性，比如说最多可以存放的单个文件为多大。有的数据库的数据是以单个文件来存放的，虽然我们很少见到数据库中的数据多到不能再放入一条记录的情况，但是作为架构师，请时刻注意，这种可能性是有的。而且如果你有幸在一家高速成长的互联网企业中，而你所负责的应用又没有经过优化的话，可能你会很快见到这种现象。这种现象的发生可能是由于操作系统不支持大文件的原因，也可能是数据库不支持大文件。不论如何，架构师应该在这种现象发生之前就把一切都准备好。对数据库中表的拆分是架构师应该遇到的另外一个困难。一般来说增加应用服务器比较简单而增加数据库服务器则是比较复杂的问题，如果一个站点由多个数据库支持，架构师需要考虑如何在保证数据一致的情况下，让多个数据库分担压力。有些解决方案是将数据库的读写分开，使得大多数的查询sql不经过核心数据库，而只是访问数据库的副本，但事实上，这种方式也只能维护规模不大的网站。对于大型的网站来说，把业务分散到不同的数据库中，只共享必要的数据，才是合理的提高网站扩展性的解决方案。<br />
其他知识<br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 作为系统架构师，可能还需要对分布式系统，负载均衡，网络安全，数据监控等等各方面都有所了解。不仅仅是了解理论知识，也要对相关的产品和业界进展有一定的认识。比如说做负载均衡最好的产品是那种。目前最常用的备份策略是什么，有什么缺点。如何使用缓存，如何做好日志分析等等。<br />
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 刚刚谈到的是架构师需要掌握的知识，然而，冰冻三尺非一日之寒。这个过程需要我们慢慢的积累。如果你已经进入到公司进行软件开发，请时刻关注你所开发软件的性能与可扩展性，而不仅仅局限在功能上，时刻想着任何一个简单的问题：我开发的模块如果放在多人并发的环境下会怎样，慢慢的就会有所心得。如果你还是一个在校学生，不要想着自己离架构师这个职位还很遥远。要知道，成为架构师的修炼之路是很长的，甚至可以说是终身的，因此早点进入学习状态，不断修炼自己。在学校期间学好离散数学，数据结构，操作系统，编译原理，体系结构，数据库原理等关键课程，并积极寻找机会到外面实习，增长自己的工作经验。如果有机会去到一些技术主导的公司中工作，就一定不要放弃这种机会，慢慢就会成长起来。最重要的，你会养成关注技术，勤于思考的好习惯。当有一天你发现自己对任何技术难题都可以一眼看到其本质，并能够将其分解为一个个可轻松解决的模块，你会由衷的感觉到知识给你带来的快乐，或许那一天，你已经是一个架构师了。</p><img src ="http://www.blogjava.net/rain1102/aggbug/246897.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/rain1102/" target="_blank">周锐</a> 2008-12-17 16:35 <a href="http://www.blogjava.net/rain1102/archive/2008/12/17/246897.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>怎样成为优秀的软件模型设计者？[转载]</title><link>http://www.blogjava.net/rain1102/archive/2008/12/15/246439.html</link><dc:creator>周锐</dc:creator><author>周锐</author><pubDate>Mon, 15 Dec 2008 08:10:00 GMT</pubDate><guid>http://www.blogjava.net/rain1102/archive/2008/12/15/246439.html</guid><wfw:comment>http://www.blogjava.net/rain1102/comments/246439.html</wfw:comment><comments>http://www.blogjava.net/rain1102/archive/2008/12/15/246439.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/rain1102/comments/commentRss/246439.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/rain1102/services/trackbacks/246439.html</trackback:ping><description><![CDATA[<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">我们期待自己成为一个优秀的软件模型设计者，但是，要怎样做，又从哪里开始呢？</span></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">将下列原则应用到你的软件工程中，你会获得立杆见影的成果。</span></div>
<div style="line-height: 16.5pt"><strong><span style="font-size: 10.5pt; color: black">1. </span></strong><strong><span style="font-size: 10.5pt; color: black">人远比技术重要 </span></strong></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">你开发软件是为了供别人使用，没有人使用的软件只是没有意义的数据的集合而已。许多在软件方面很有成就的行家在他们事业的初期却表现平平，因为他们那时侯将主要精力都集中在技术上。显然，构件（</span><span style="font-size: 10.5pt; color: black">components</span><span style="font-size: 10.5pt; color: black">），</span><span style="font-size: 10.5pt; color: black">EJB</span><span style="font-size: 10.5pt; color: black">（</span><span style="font-size: 10.5pt; color: black">Enterprise <a title="Java爱好者" href="http://www.blogjava.net/rain1102" >Java</a> Beans</span><span style="font-size: 10.5pt; color: black">）和代理（</span><span style="font-size: 10.5pt; color: black">agent</span><span style="font-size: 10.5pt; color: black">）是很有趣的东西。但是对于用户来说，如果你设计的软件很难使用或者不能满足他们的需求，后台用再好的技术也于事无补。多花点时间到软件需求和设计一个使用户能很容易理解的界面上。</span></div>
<div style="line-height: 16.5pt"><strong><span style="font-size: 10.5pt; color: black">2. </span></strong><strong><span style="font-size: 10.5pt; color: black">理解你要实现的东西 </span></strong></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">好的软件设计人员把大多数时间花费在建立系统模型上，偶尔写一些源代码，但那只不过是为了验证设计过程中所遇到的问题。这将使他们的设计方案更加可行。</span></div>
<div style="line-height: 16.5pt"><strong><span style="font-size: 10.5pt; color: black">3. </span></strong><strong><span style="font-size: 10.5pt; color: black">谦虚是必须的品格</span></strong></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">你不可能知道一切，你甚至要很努力才能获得足够用的知识。软件开发是一项复杂而艰巨的工作，因为软件开发所用到的工具和技术是在不断更新的。而且，一个人也不可能了解软件开发的所有过程。在日常生活中你每天接触到的新鲜事物可能不会太多。但是对于从事软件开发的人来说，每天可以学习很多新东西（如果愿意的话）。</span></div>
<div style="line-height: 16.5pt"><strong><span style="font-size: 10.5pt; color: black">4. </span></strong><strong><span style="font-size: 10.5pt; color: black">需求就是需求</span></strong></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">如果你没有任何需求，你就不要动手开发任何软件。成功的软件取决于时间（在用户要求的时间内完成）、预算和是否满足用户的需求。如果你不能确切知道用户需要的是什么，或者软件的需求定义，那么你的工程注定会失败。</span></div>
<div style="line-height: 16.5pt"><strong><span style="font-size: 10.5pt; color: black">5. </span></strong><strong><span style="font-size: 10.5pt; color: black">需求其实很少改变，改变的是你对需求的理解</span></strong></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">Object ToolSmiths</span><span style="font-size: 10.5pt; color: black">公司（</span><span style="font-size: 10.5pt; color: black">www.objecttoolsmiths.com</span><span style="font-size: 10.5pt; color: black">）的</span><span style="font-size: 10.5pt; color: black">Doug Smith</span><span style="font-size: 10.5pt; color: black">常喜欢说：</span><span style="font-size: 10.5pt; color: black">&#8220;</span><span style="font-size: 10.5pt; color: black">分析是一门科学，设计是一门艺术</span><span style="font-size: 10.5pt; color: black">&#8221;</span><span style="font-size: 10.5pt; color: black">。他的意思是说在众多的</span><span style="font-size: 10.5pt; color: black">&#8220;</span><span style="font-size: 10.5pt; color: black">正确</span><span style="font-size: 10.5pt; color: black">&#8221;</span><span style="font-size: 10.5pt; color: black">分析模型中只存在一个最</span><span style="font-size: 10.5pt; color: black">&#8220;</span><span style="font-size: 10.5pt; color: black">正确</span><span style="font-size: 10.5pt; color: black">&#8221;</span><span style="font-size: 10.5pt; color: black">分析模型可以完全满足解决某个具体问题的需要（我理解的意思是需求分析需要一丝不苟、精确的完成</span><span style="font-size: 10.5pt; color: black">,</span><span style="font-size: 10.5pt; color: black">而设计的时候反而可以发挥创造力和想象力</span><span style="font-size: 10.5pt; color: black"> - </span><span style="font-size: 10.5pt; color: black">译者注）。</span></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">如果需求经常改动，很可能是你没有作好需求分析，并不是需求真的改变了。</span></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">你可以抱怨用户不能告诉你他们想得到什么，但是不要忘记，收集需求信息是你工作。</span></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">你可以说是新来的开发人员把事情搞得一团糟，但是，你应该确定在工程的第一天就告诉他们应该做什么和怎样去做。</span></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">如果你觉得公司不让你与用户充分接触，那只能说明公司的管理层并不是真正支持你的项目。</span></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">你可以抱怨公司有关软件工程的管理制度不合理，但你必须了解大多同行公司是怎么做的。</span></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">你可以借口说你们的竞争对手的成功是因为他们有了一个新的理念，但是为什么你没先想到呢？</span></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">需求真正改变的情况很少，但是没有做好需求分析工作的理由却很多。</span></div>
<div style="line-height: 16.5pt"><strong><span style="font-size: 10.5pt; color: black">6. </span></strong><strong><span style="font-size: 10.5pt; color: black">经常阅读</span></strong></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">在这个每日都在发生变化的产业中，你不可能在已取得的成就上陶醉太久。</span></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">每个月至少读</span><span style="font-size: 10.5pt; color: black">2</span><span style="font-size: 10.5pt; color: black">、</span><span style="font-size: 10.5pt; color: black">3</span><span style="font-size: 10.5pt; color: black">本专业杂志或者</span><span style="font-size: 10.5pt; color: black">1</span><span style="font-size: 10.5pt; color: black">本专业书籍。保持不落伍需要付出很多的时间和金钱，但会使你成为一个很有实力的竞争者。</span></div>
<div style="line-height: 16.5pt"><strong><span style="font-size: 10.5pt; color: black">7. </span></strong><strong><span style="font-size: 10.5pt; color: black">降低软件模块间的耦合度</span></strong></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">高耦合度的系统是很难维护的。一处的修改引起另一处甚至更多处的变动。</span></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">你可以通过以下方法降低程序的耦合度：隐藏实现细节，强制构件接口定义，不使用公用数据结构，不让应用程序直接操作数据库（我的经验法则是：当应用程序员在写</span><span style="font-size: 10.5pt; color: black">SQL</span><span style="font-size: 10.5pt; color: black">代码的时候，你的程序的耦合度就已经很高了）。</span></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">耦合度低的软件可以很容易被重用、维护和扩充。</span></div>
<div style="line-height: 16.5pt"><strong><span style="font-size: 10.5pt; color: black">8. </span></strong><strong><span style="font-size: 10.5pt; color: black">提高软件的内聚性</span></strong></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">如果一个软件的模块只实现一个功能，那么该模块具有高内聚性。高内聚性的软件更容易维护和改进。</span></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">判断一个模块是否有高的内聚性，看一看你是否能够用一个简单的句子描述它的功能就行了。如果你用了一段话或者你需要使用类似</span><span style="font-size: 10.5pt; color: black">&#8220;</span><span style="font-size: 10.5pt; color: black">和</span><span style="font-size: 10.5pt; color: black">&#8221;</span><span style="font-size: 10.5pt; color: black">、</span><span style="font-size: 10.5pt; color: black">&#8220;</span><span style="font-size: 10.5pt; color: black">或</span><span style="font-size: 10.5pt; color: black">&#8221;</span><span style="font-size: 10.5pt; color: black">等连词，则说明你需要将该模块细化。</span></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">只有高内聚性的模块才可能被重用。</span></div>
<div style="line-height: 16.5pt"><strong><span style="font-size: 10.5pt; color: black">9. </span></strong><strong><span style="font-size: 10.5pt; color: black">考虑软件的移植性</span></strong></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">移植是软件开发中一项具体而又实际的工作，不要相信某些软件工具的广告宣传（比如</span><span style="font-size: 10.5pt; color: black"><a title="Java爱好者" href="http://www.blogjava.net/rain1102" >Java</a> </span><span style="font-size: 10.5pt; color: black">的宣传口号</span><span style="font-size: 10.5pt; color: black">write once run many ? </span><span style="font-size: 10.5pt; color: black">译者注）。</span></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">即使仅仅对软件进行常规升级，也要把这看得和向另一个操作系统或数据库移植一样重要。</span></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">记得从</span><span style="font-size: 10.5pt; color: black">16</span><span style="font-size: 10.5pt; color: black">位</span><span style="font-size: 10.5pt; color: black">Windows</span><span style="font-size: 10.5pt; color: black">移植到</span><span style="font-size: 10.5pt; color: black">32</span><span style="font-size: 10.5pt; color: black">位</span><span style="font-size: 10.5pt; color: black">windows</span><span style="font-size: 10.5pt; color: black">的</span><span style="font-size: 10.5pt; color: black">&#8220;</span><span style="font-size: 10.5pt; color: black">乐趣</span><span style="font-size: 10.5pt; color: black">&#8221;</span><span style="font-size: 10.5pt; color: black">吗</span><span style="font-size: 10.5pt; color: black">？当你使用了某个操作系统的特性，如它的进程间通信</span><span style="font-size: 10.5pt; color: black">(IPC)</span><span style="font-size: 10.5pt; color: black">策略，或用某数据库专有语言写了存储过程。你的软件和那个特定的产品结合度就已经很高了。</span></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">好的软件设计者把那些特有的实现细节打包隐藏起来，所以，当那些特性该变的时候，你的仅仅需要更新那个包就可以了。</span></div>
<div style="line-height: 16.5pt"><strong><span style="font-size: 10.5pt; color: black">10. </span></strong><strong><span style="font-size: 10.5pt; color: black">接受变化</span></strong></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">这是一句老话了：唯一不变的只有变化。</span></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">你应该将所有系统将可能发生的变化以及潜在需求记录下来</span><span style="font-size: 10.5pt; color: black">,</span><span style="font-size: 10.5pt; color: black">以便将来能够实现（参见</span><span style="font-size: 10.5pt; color: black">&#8220;Architecting for Change&#8221;</span><span style="font-size: 10.5pt; color: black">，</span><span style="font-size: 10.5pt; color: black">Thinking Objectively, May 1999</span><span style="font-size: 10.5pt; color: black">）</span></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">通过在建模期间考虑这些假设的情况，你就有可能开发出足够强壮且容易维护的软件。设计强壮的软件是你最基本的目标。</span></div>
<div style="line-height: 16.5pt"><strong><span style="font-size: 10.5pt; color: black">11. </span></strong><strong><span style="font-size: 10.5pt; color: black">不要低估对软件规模的需求</span></strong></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">Internet </span><span style="font-size: 10.5pt; color: black">带给我们的最大的教训是你必须在软件开发的最初阶段就考虑软件规模的可扩充性。</span></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">今天只有</span><span style="font-size: 10.5pt; color: black">100</span><span style="font-size: 10.5pt; color: black">人的部门使用的应用程序，明天可能会被有好几万人的组织使用，下月，通过因特网可能会有几百万人使用它。</span></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">在软件设计的初期，根据在用例模型中定义的必须支持的基本事务处理，确定软件的基本功能。然后，在建造系统的时候再逐步加入比较常用的功能。</span></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">在设计的开始考虑软件的规模需求，避免在用户群突然增大的情况下，重写软件。</span></div>
<div style="line-height: 16.5pt"><strong><span style="font-size: 10.5pt; color: black">12. </span></strong><strong><span style="font-size: 10.5pt; color: black">性能仅仅是很多设计因素之一</span></strong></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">关注软件设计中的一个重要因素</span><span style="font-size: 10.5pt; color: black">--</span><span style="font-size: 10.5pt; color: black">性能，这好象也是用户最关心的事情。一个性能不佳的软件将不可避免被重写。</span></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">但是你的设计还必须具有可靠性，可用性，便携性和可扩展性。你应该在工程开始就应该定义并区分好这些因素，以便在工作中恰当使用。性能可以是，也可以不是优先级最高的因素，我的观点是，给每个设计因素应有的考虑。</span></div>
<div style="line-height: 16.5pt"><strong><span style="font-size: 10.5pt; color: black">13. </span></strong><strong><span style="font-size: 10.5pt; color: black">管理接口</span></strong></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">&#8220;UML User Guide&#8221;</span><span style="font-size: 10.5pt; color: black">（</span><span style="font-size: 10.5pt; color: black">Grady Booch</span><span style="font-size: 10.5pt; color: black">，</span><span style="font-size: 10.5pt; color: black">Ivar Jacobson</span><span style="font-size: 10.5pt; color: black">和</span><span style="font-size: 10.5pt; color: black">Jim Rumbaugh ,Addison Wesley, 1999</span><span style="font-size: 10.5pt; color: black">）中指出，你应该在开发阶段的早期就定义软件模块之间的接口。</span></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">这有助于你的开发人员全面理解软件的设计结构并取得一致意见，让各模块开发小组相对独立的工作。一旦模块的接口确定之后，模块怎样实现就不是很重要了。</span></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">从根本上说，如果你不能够定义你的模块</span><span style="font-size: 10.5pt; color: black">&#8220;</span><span style="font-size: 10.5pt; color: black">从外部看上去会是什么样子</span><span style="font-size: 10.5pt; color: black">&#8221;</span><span style="font-size: 10.5pt; color: black">，你肯定也不清楚模块内要实现什么。</span></div>
<div style="line-height: 16.5pt"><strong><span style="font-size: 10.5pt; color: black">14. </span></strong><strong><span style="font-size: 10.5pt; color: black">走近路需要更长的时间</span></strong></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">在软件开发中没有捷径可以走。</span></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">缩短你的在需求分析上花的时间，结果只能是开发出来的软件不能满足用户的需求，必须被重写。</span></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">在软件建模上每节省一周，在将来的编码阶段可能会多花几周时间，因为你在全面思考之前就动手写程序。</span></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">你为了节省一天的测试时间而漏掉了一个</span><span style="font-size: 10.5pt; color: black">bug</span><span style="font-size: 10.5pt; color: black">，在将来的维护阶段，可能需要花几周甚至几个月的时间去修复。与其如此，还不如重新安排一下项目计划。</span></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">避免走捷径，只做一次但要做对（</span><span style="font-size: 10.5pt; color: black">do it once by doing it right</span><span style="font-size: 10.5pt; color: black">）。</span></div>
<div style="line-height: 16.5pt"><strong><span style="font-size: 10.5pt; color: black">15. </span></strong><strong><span style="font-size: 10.5pt; color: black">别信赖任何人</span></strong></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">产品和服务销售公司不是你的朋友，你的大部分员工和高层管理人员也不是。</span></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">大部分产品供应商希望把你牢牢绑在他们的产品上，可能是操作系统，数据库或者某个开发工具。</span></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">大部分的顾问和承包商只关心你的钱并不是你的工程（停止向他们付款，看一看他们会在周围呆多长时间）。</span></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">大部分程序员认为他们自己比其他人更优秀，他们可能抛弃你设计的模型而用自己认为更好的。</span></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">只有良好的沟通才能解决这些问题。</span></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">要明确的是，不要只依靠一家产品或服务提供商，即使你的公司（或组织）已经在建模、文档和过程等方面向那个公司投入了很多钱。</span></div>
<div style="line-height: 16.5pt"><strong><span style="font-size: 10.5pt; color: black">16. </span></strong><strong><span style="font-size: 10.5pt; color: black">证明你的设计在实践中可行</span></strong></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">在设计的时候应当先建立一个技术原型，</span><span style="font-size: 10.5pt; color: black">或者称为</span><span style="font-size: 10.5pt; color: black">&#8220;</span><span style="font-size: 10.5pt; color: black">端到端</span><span style="font-size: 10.5pt; color: black">&#8221;</span><span style="font-size: 10.5pt; color: black">原型。以证明你的设计是能够工作的。</span></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">你应该在开发工作的早期做这些事情，因为，如果软件的设计方案是不可行的，在编码实现阶段无论采取什么措施都于事无补。技术原型将证明你的设计的可行性，从而，你的设计将更容易获得支持。</span></div>
<div style="line-height: 16.5pt"><strong><span style="font-size: 10.5pt; color: black">17. </span></strong><strong><span style="font-size: 10.5pt; color: black">应用已知的模式</span></strong></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">目前，我们有大量现成的分析和设计模式以及问题的解决方案可以使用。</span></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">一般来说，好的模型设计和开发人员，都会避免重新设计已经成熟的并被广泛应用的东西。</span><span style="font-size: 10.5pt; color: black"> <br />
http://www.ambysoft.com/processPatternsPage.html </span><span style="font-size: 10.5pt; color: black">收藏了许多开发模式的信息。</span></div>
<div style="line-height: 16.5pt"><strong><span style="font-size: 10.5pt; color: black">18. </span></strong><strong><span style="font-size: 10.5pt; color: black">研究每个模型的长处和弱点</span></strong></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">目前有很多种类的模型可以使用</span><span style="font-size: 10.5pt; color: black">,</span><span style="font-size: 10.5pt; color: black">如下图所示。用例捕获的是系统行为需求，数据模型则描述支持一个系统运行所需要的数据构成。你可能会试图在用例中加入实际数据描述，但是，这对开发者不是非常有用。同样，数据模型对描述软件需求来说是无用的。每个模型在你建模过程中有其相应的位置，但是，你需要明白在什么地方，什么时候使用它们。</span></div>
<div style="line-height: 16.5pt"><strong><span style="font-size: 10.5pt; color: black">19. </span></strong><strong><span style="font-size: 10.5pt; color: black">在现有任务中应用多个模型</span></strong></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">当你收集需求的时候，考虑使用用例模型，用户界面模型和领域级的类模型。</span></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">当你设计软件的时候，应该考虑制作类模型，顺序图、状态图、协作图和最终的软件实际物理模型。</span></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">程序设计人员应该慢慢意识到，仅仅使用一个模型而实现的软件要么不能够很好地满足用户的需求，要么很难扩展。</span></div>
<div style="line-height: 16.5pt"><strong><span style="font-size: 10.5pt; color: black">20. </span></strong><strong><span style="font-size: 10.5pt; color: black">教育你的听众</span></strong></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">你花了很大力气建立一个很成熟的系统模型，而你的听众却不能理解它们，甚至更糟－连为什么要先建立模型都不知道。那么你的工作是毫无意义的。</span></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">教给你开发人员基本的建模知识；否则，他们会只看看你画的漂亮图表，然后继续编写不规范的程序。</span></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">另外，</span><span style="font-size: 10.5pt; color: black">你还需要告诉你的用户一些需求建模的基础知识。给他们解释你的用例</span><span style="font-size: 10.5pt; color: black">(uses case)</span><span style="font-size: 10.5pt; color: black">和用户界面模型，以使他们能够明白你要表达地东西。当每个人都能使用一个通用的设计语言的时候（比如</span><span style="font-size: 10.5pt; color: black">UML-</span><span style="font-size: 10.5pt; color: black">译者注），你的团队才能实现真正的合作。</span></div>
<div style="line-height: 16.5pt"><strong><span style="font-size: 10.5pt; color: black">21. </span></strong><strong><span style="font-size: 10.5pt; color: black">带工具的傻瓜还是傻瓜</span></strong></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">你给我</span><span style="font-size: 10.5pt; color: black">CAD/CAM</span><span style="font-size: 10.5pt; color: black">工具，请我设计一座桥。但是，如果那座桥建成的话，我肯定不想当第一个从桥上过的人，因为我对建筑一窍不通。</span></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">使用一个很优秀的</span><span style="font-size: 10.5pt; color: black">CASE</span><span style="font-size: 10.5pt; color: black">工具并不能使你成为一个建模专家，只能使你成为一个优秀</span><span style="font-size: 10.5pt; color: black">CASE</span><span style="font-size: 10.5pt; color: black">工具的使用者。成为一个优秀的建模专家需要多年的积累，不会是一周针对某个价值几千美元工具的培训。一个优秀的</span><span style="font-size: 10.5pt; color: black">CASE</span><span style="font-size: 10.5pt; color: black">工具是很重要，但你必须学习使用它，并能够使用它设计它支持的模型。</span></div>
<div style="line-height: 16.5pt"><strong><span style="font-size: 10.5pt; color: black">22. </span></strong><strong><span style="font-size: 10.5pt; color: black">理解完整的过程</span></strong></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">好的设计人员应该理解整个软件过程，尽管他们可能不是精通全部实现细节。</span></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">软件开发是一个很复杂的过程，还记得《</span><span style="font-size: 10.5pt; color: black">object-oriented software process</span><span style="font-size: 10.5pt; color: black">》第</span><span style="font-size: 10.5pt; color: black">36</span><span style="font-size: 10.5pt; color: black">页的内容吗？除了编程、建模、测试等你擅长工作外，还有很多工作要做。</span></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">好的设计者需要考虑全局。必须从长远考虑如何使软件满足用户需要，如何提供维护和技术支持等。</span></div>
<div style="line-height: 16.5pt"><strong><span style="font-size: 10.5pt; color: black">23. </span></strong><strong><span style="font-size: 10.5pt; color: black">常做测试，早做测试</span></strong></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">如果测试对你的软件来说是无所谓的，那么你的软件多半也没什么必要被开发出来。</span></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">建立一个技术原型供技术评审使用，以检验你的软件模型。</span></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">在软件生命周期中，越晚发现的错误越难修改，修改成本越昂贵。尽可能早的做测试是很值得的。</span></div>
<div style="line-height: 16.5pt"><strong><span style="font-size: 10.5pt; color: black">24. </span></strong><strong><span style="font-size: 10.5pt; color: black">把你的工作归档</span></strong></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">不值得归档的工作往往也不值得做。归档你的设想，以及根据设想做出的决定；归档软件模型中很重要但不很明显的部分。</span><span style="font-size: 10.5pt; color: black">给每个模型一些概要描述以使别人很快明白模型所表达的内容。</span></div>
<div style="line-height: 16.5pt"><strong><span style="font-size: 10.5pt; color: black">25. </span></strong><strong><span style="font-size: 10.5pt; color: black">技术会变，基本原理不会</span></strong></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">如果有人说</span><span style="font-size: 10.5pt; color: black">&#8220;</span><span style="font-size: 10.5pt; color: black">使用某种开发语言、某个工具或某某技术，我们就不需要再做需求分析，建模，编码或测试</span><span style="font-size: 10.5pt; color: black">&#8221;</span><span style="font-size: 10.5pt; color: black">。不要相信，这只说明他还缺乏经验。抛开技术和人的因素，实际上软件开发的基本原理自</span><span style="font-size: 10.5pt; color: black">20</span><span style="font-size: 10.5pt; color: black">世纪</span><span style="font-size: 10.5pt; color: black">70</span><span style="font-size: 10.5pt; color: black">年代以来就没有改变过。你必须还定义需求，建模，编码，测试，配置，面对风险，发布产品，管理工作人员等等。</span></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">软件建模技术是需要多年的实际工作才能完全掌握的。好在你可以从我的建议开始，完善你们自己的软件开发经验。</span></div>
<div style="line-height: 16.5pt"><span style="font-size: 10.5pt; color: black">以鸡汤开始，加入自己的蔬菜。然后，开始享受你自己的丰盛晚餐吧。</span></div><img src ="http://www.blogjava.net/rain1102/aggbug/246439.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/rain1102/" target="_blank">周锐</a> 2008-12-15 16:10 <a href="http://www.blogjava.net/rain1102/archive/2008/12/15/246439.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item></channel></rss>