﻿<?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-Brian Sun @ 爬树的泡泡-随笔分类-软件</title><link>http://www.blogjava.net/briansun/category/436.html</link><description>&lt;marquee direction="down" scrollamount=4 height="120" align="right"&gt;
&lt;a href="http://www.blogjava.net/briansun/archive/2005/09/03/11884.html"&gt;关于洞穴寓言的几部电影&lt;/a&gt;&lt;br&gt;
&lt;a href="http://www.blogjava.net/briansun/archive/2005/08/31/11634.html"&gt;关于AOP的七个猜想&lt;/a&gt;&lt;br&gt;
&lt;a href="http://www.blogjava.net/briansun/archive/2005/07/31/8813.html"&gt;测试驱动开发全功略&lt;/a&gt;&lt;br&gt;
&lt;a href="http://www.blogjava.net/briansun/archive/2005/07/21/8095.html"&gt;体验经济在软件&lt;/a&gt;&lt;br&gt;
&lt;a href="http://www.blogjava.net/briansun/archive/2005/07/20/8028.html"&gt;NXUnit 中文说明&lt;/a&gt;&lt;br&gt;
&lt;a href="http://www.blogjava.net/briansun/archive/2005/07/15/7765.html"&gt;发表我自己的开源软件&lt;/a&gt;&lt;br&gt;
&lt;a href="http://www.blogjava.net/briansun/archive/2005/04/16/3336.html"&gt;4月16日评点IBM&lt;/a&gt;&lt;br&gt;
&lt;a href="http://www.blogjava.net/briansun/archive/2005/04/04/2808.html"&gt;4月4日评点Google&lt;/a&gt;&lt;br&gt;
&lt;a href="http://www.blogjava.net/briansun/archive/2005/03/27/2505.html"&gt;3月27日评点版权制度&lt;/a&gt;&lt;br&gt;
&lt;a href="http://www.blogjava.net/briansun/archive/2005/03/21/2274.html"&gt;天下归一，谈EclipseCon2005&lt;/a&gt;&lt;br&gt;
&lt;a href="http://www.blogjava.net/briansun/archive/2005/03/20/2270.html"&gt;软件标准的生命周期&lt;/a&gt;&lt;br&gt;
&lt;a href="http://www.blogjava.net/briansun/archive/2005/03/18/2205.html"&gt;2005年度Jolt大奖&lt;/a&gt;&lt;br&gt;
&lt;a href="http://www.blogjava.net/briansun/archive/2005/03/14/2067.html"&gt;3月14日评点Microsoft Office&lt;/a&gt;&lt;br&gt;
&lt;a href="http://www.blogjava.net/briansun/archive/2005/03/14/2063.html"&gt;3月14日评点OMG&lt;/a&gt;&lt;br&gt;
&lt;a href="http://www.blogjava.net/briansun/archive/2005/03/12/1963.html"&gt;关于UI的不同解释&lt;/a&gt;&lt;br&gt;
&lt;a href="http://www.blogjava.net/briansun/archive/2005/03/07/1786.html"&gt;非理智的抗议，只为JDO&lt;/a&gt;&lt;br&gt;
&lt;a href="http://www.blogjava.net/briansun/archive/2005/03/01/1597.html"&gt;关于ERP的未来&lt;/a&gt;&lt;br&gt;
&lt;a href="http://www.blogjava.net/briansun/archive/2005/02/27/1534.html"&gt;有没有可能以开源软件为平台建构ERP？&lt;/a&gt;&lt;br&gt;
&lt;a href="http://www.blogjava.net/briansun/archive/2005/02/26/1518.html"&gt;UI框架的组织模式&lt;/a&gt;&lt;br&gt;
&lt;a href="http://www.blogjava.net/briansun/archive/2005/02/19/1321.html"&gt;关于人工智能&lt;/a&gt;&lt;br&gt;
&lt;/marquee&gt;</description><language>zh-cn</language><lastBuildDate>Mon, 21 May 2007 02:14:42 GMT</lastBuildDate><pubDate>Mon, 21 May 2007 02:14:42 GMT</pubDate><ttl>60</ttl><item><title>XMIND与MindManager从使用者角度的差别是什么？</title><link>http://www.blogjava.net/briansun/archive/2007/05/21/118810.html</link><dc:creator>Brian Sun</dc:creator><author>Brian Sun</author><pubDate>Mon, 21 May 2007 02:08:00 GMT</pubDate><guid>http://www.blogjava.net/briansun/archive/2007/05/21/118810.html</guid><wfw:comment>http://www.blogjava.net/briansun/comments/118810.html</wfw:comment><comments>http://www.blogjava.net/briansun/archive/2007/05/21/118810.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/briansun/comments/commentRss/118810.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/briansun/services/trackbacks/118810.html</trackback:ping><description><![CDATA[<span style="font-weight: bold;">1.100%纯中文。</span><br>XMIND改变了中国人没有自己的思维导图工具的现状。国外的所有软件厂商都没有把中文版列为其发展方向之一，且在处理中文的过程中，几乎无一例外的存在Bug。使用MindManager一段时间之后的很多中国用户都发现一些Notes丢失了，一些中文变成了乱码。但XMIND没有，它是100%纯中文设计，中文处理非常稳定。以至于新加波的代理商都以&#8220;the best practice of using Chinese&#8221;为由代理XMIND。且XMIND的研发团队在国内，各类服务都比较方便。<br><br><span style="font-weight: bold;">2.适合中国人的思考方式。</span><br>XMIND不仅考虑了中文处理和中文界面，还更考虑了中国人的思维习惯。国内权威IT产品评测杂志《个人电脑》在2007年第5期中介绍了XMIND 2007，经过详细评测给出的评价之一就是&#8220;与国外的同类软件相比，XMIND2007更加符合我们的思维习惯。&#8221;<br><br><span style="font-weight: bold;">3.更易用，零学习曲线。</span><br>三个特性体现XMIND的易用性：<br><br>3.1 XMIND的过滤功能非常直观，用户可以通过图标将思维导图分成很多层，可单独查看其中的一层，是个人计划、项目管理等领域的法宝。<br><br>3.2 XMIND的图例功能非常有用，让用户再分享自己绘制的思维导图时可以方便的看到图上所用到的所有图标，以及图标的含义。有了此项功能，用户才愿意打印思维导图到纸上。<br><br>3.3 XMIND的外框功能与MindManager有很大分歧。后者认为外框的含义在于强调，所以一个外框只能加在一个分支上，但XMIND认为除了强调外，外框还应该能体现&#8220;弱分类&#8221;的功能，所以XMIND可以随意选择几个分支添加外框，相近的分支被安排在同一个外框中。<br><br><span style="font-weight: bold;">4.神奇的关联图与强大的工作簿。</span><br>XMIND允许用户将多张图放在同一个文件中，这种设计更类似于现实生活中的图纸与工作簿。用户将相同或相近主题下的图放在同一个文件中也便于与他人分享。<br><br>此外，同一个工作簿中的图可以具有一定的关联性，这是XMIND的独特创造。两张图中具备关联性的分支除了位置和关系不同外，文字和图标都是相同的。很多用户用关联图表达相同内容的不同分类法，也有很多用户用此来表达概述和详细内容之间的关系。<br><br><span style="font-weight: bold;">5.个性化窗口布局提高工作效率。</span><br>XMIND可以根据您的喜好随意改变窗体的布局，大小，层叠样式。在XMIND中可以拥有您自己的风格，将某些窗体拖拽到您认为最合适的位置和大小，或者选择打开某些窗体，关闭另一些。当您在工作簿页签栏上双击时，整个工作簿就会以最大化的样式呈现，再次双击又会回到原来的布局格式，改变灵活自如。这样，您的XMIND就可以在一台电脑上为不同个性，不同喜好的用户提供让大家都满意的布局格式和窗体效果，满足各类个性化需求，在符合各类人群使用习惯的基础上进一步提高效率。<br><br><span style="font-weight: bold;">6.兼容其它思维导图保护客户投资。</span><br>作为一款出色的思维导图软件，XMIND充分考虑到使用者已有的资源及习惯，方便的将其他格式的思维导图（如FreeMind格式和MindManager格式）导入成XMIND支持的.xmap格式，可以充分保护客户对XMIND的投资。一旦拥有XMIND，可以拥有多种思维导图软件带来的资源和信息，不必担心集成与兼容，更无需浪费时间重复劳动，给与客户极大的使用便利性。<br><br><span style="font-weight: bold;">7.降低客户的成本。</span><br>XMIND在海外市场和国内市场的零售价均不到MindManager的三分之一。提供整体解决方案的价格也远远低于MindManager。<br><br><span style="font-weight: bold;">XMIND官方网站：</span><a style="font-weight: bold;"  href="http://www.xmind.org/">http://www.xmind.org/</a><span style="font-weight: bold;">
</span><br><br>
<br><img src ="http://www.blogjava.net/briansun/aggbug/118810.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/briansun/" target="_blank">Brian Sun</a> 2007-05-21 10:08 <a href="http://www.blogjava.net/briansun/archive/2007/05/21/118810.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>Eclipse在做什么</title><link>http://www.blogjava.net/briansun/archive/2007/04/18/111709.html</link><dc:creator>Brian Sun</dc:creator><author>Brian Sun</author><pubDate>Wed, 18 Apr 2007 10:53:00 GMT</pubDate><guid>http://www.blogjava.net/briansun/archive/2007/04/18/111709.html</guid><wfw:comment>http://www.blogjava.net/briansun/comments/111709.html</wfw:comment><comments>http://www.blogjava.net/briansun/archive/2007/04/18/111709.html#Feedback</comments><slash:comments>11</slash:comments><wfw:commentRss>http://www.blogjava.net/briansun/comments/commentRss/111709.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/briansun/services/trackbacks/111709.html</trackback:ping><description><![CDATA[很久没关心Eclipse基金会的动作了，只是不断在使用，不断在开发，不断在教别人使用和开发，然后就是等待Eclipse的下个版本。那么，Eclipse基金会究竟在干什么呢？我不想写篇很长的Blog了，只是随便谈谈最近的几个映像：<br><br><span style="font-weight: bold;">1。Eclipse 3.3</span><br>如果我的推算没有问题的话，今年的第三季度我们就可以拿到正式版的3.3了，3.3好像没有什么太大的动作了，我只记得3.2的时候搞了一个MDC（百万下载挑战），据说在预订一半多的时间里就实现了百万下载量。回头看看Firefox好像几乎没花什么精力下载量就达到千万级别了，不是一个类型的软件确实没法比啊。<br><br>看了3.3M6的一些表现，Forms包的外观有些改善，但是不知道有没有结构上的调整；Application扩展点的API改了很多，名字也比原来合理了，不过最近正在开发中的一些项目又要重构了，呵呵；最令人激动还是View终于可以折叠到一边了，而不是原来那样最小化了之后还占很多位置，而且最大化也更酷炫了，得益于View的新折叠方式。<br><br><span style="font-weight: bold;">2。越来越重视MacOSX</span><br>SWT 3.3的&#8220;New and Noteworthy&#8221;可以看到这个趋势。记得我去年与Sun公司的James Bai谈到Eclipse与NetBeans时，我就表达了自己的观点，好像Blog里面也有。事实上，&#8220;惯用法和外观&#8221;在MacOSX系统上的重要地位是没用过苹果电脑的人无法想象的，Eclipse在Windows确实很漂亮，但是之前的版本在MacOSX上还是远不如NetBeans的。我自己也遇到了这样的问题，我们在Windows上开发有&#8220;助记符&#8221;的问题，比如文件菜单，应该写成&#8220;文件(&amp;F)&#8221;，这样F下面有条小横线，用户按Alt-F就可以直接打开文件菜单，但是在Mac上没有这样的设计，Eclipse展示出来仍然是这样，就显得有明显从Windows移植的痕迹。除了Mac的菜单外，Mac的窗体、Mac的工具栏、Mac的任务栏、Mac的快捷键都有很多与Windows不同的地方，Eclipse要加油了啊～～<br><br>回到说SWT，3.3在MacOSX上有了不少改善，增加了TrayItem，增加了彩色鼠标指针，还改了一个reparent的bug。<br><br><span style="font-weight: bold;">3。Ajax是大方向</span><br>前段时间炒作了一条新闻，说Eclipse基金会同时发布了三款用于Ajax开发的插件，这个说法是欠妥的。因为这三个项目都是很久以前就有的，现在把他们拿到一起来说，根本原因就是为了回应现在炒作很凶的Ajax。其中&#8220;Dynamic Languages Toolkit&#8221;没什么稀奇的，NetBeans也已经做了，但我相信Eclipse在易用性方面一定又是做到最好；&#8220;Ajax Toolkit Framework&#8221;也就是ATF是三者中最红的，现在要合并进WTP了，是为Dojo、Rico、Zimbra这些API的开发人员提供集成，套用行话说，就是&#8220;Ajax开发人员终于有了自己的IDE了（欢呼+大笑）&#8221;；唯独只有&#8220;Rich Ajax Platform&#8221;（RAP）最值得一提。<br><br>这是一个与众不同的项目，非常具有前瞻性和远见性，这也是Eclipse一贯的做事风格。RAP的缩写是来自于RCP的，RCP已经家喻户晓了，很多知名项目比如Lotus Notes 8和RSSOwl都是基于RCP的，RCP的程序员也很多，&#8220;如遇危难，RCP可以将兵！&#8221;但是面对Ajax一夜来袭，很多Rich Client应用程序开始希望自己能够搬到Web上去的，可是怎么搬呢？把Java代码翻译成javascript吗？我们都知道真正伟大的程序员都是在Java平台上的，而Java程序员大都不喜欢javascript这样高效但不严谨的风格，尤其是不好调试这一项，使得javascript项目的成本随规模成几何级数递增，这种事情放在Google这样钱花不掉的公司身上还行，但是要放在小公司上就捉襟见肘了。<br><br>所以行业内的专家经过这几年的反复斟酌，得到的结论是，终极的解决方案还是要让程序员手写Java代码，出来的却是javascript效果。那如何实现这样的转变了，有两个方案。一是写一个编译器，首先给出一个限定的Java API库，只有utils包、io包、lang包的少数功能和标准控件，最好是SWT式的，大家都很习惯了，如果程序员仅用这些API（和自己编写的API）写代码，就可以被这个编译器丝毫不差的编译成javascript代码，在本地执行和在Web上执行达到相同的效果，这样完全可以调试，也可以扩展这些API。这种解决方案以Google的GWT为代表。二是写一个服务器，这样就可以用全套的Java API，但是不能用AWT和Swing，再给出一组标准控件，（最好是SWT式的，大家都很习惯了），程序员所写的Java代码其实是在服务器上运行的，服务器根据这段代码的操作，把相应的结果反馈给Client端也就是浏览器，而浏览器以javascript的方式展现和接收事件。这种解决方案的代表，就是RAP。<br><br>还要说的一点就是后者其实有个帮手，也算很多Ajax网站的诀窍，就是JSON。JSON是把一个Map（名值对组）序列化成XML的工具，如果这样解释好像没什么新奇的。。。那么好，应广大JSON粉丝的强烈要求，我把JSON的解释改成：&#8220;JSON就是一个你在服务器端把JavaObject给它，就能在浏览器端取出一个javascript object的神奇而又强大的工具，而它的实现机制，只不过是把一个Map序列化成XML&#8221;！<br><br>这两个方案有明显的差别，可以说根本不是一种技术，但是他们很可能都有前途，都是王者之道，一个齐桓公一个晋文公，都有机会成为霸主，也完全有可能鼎足而立，开发人员选择谁，完全是根据项目的情况，甚至有可能。。。开发一个联合的方案。。。把GWT封装成一个Eclipse RAP的插件。<br><br><span style="font-weight: bold;">4。看看Summer Of Code</span><br>不小心点进了Google的Summer Of Code，之前就已经关注过一些，但是好奇心还没有驱使我点Eclipse Foundation进去看，今天终于按奈不住了。。。先简单介绍一下Google SoC[http://code.google.com/soc/]，其实是这样的，很多开源软件基金会想花钱请一些比较牛的大学生来开发一些代码（这些都是最著名的开源软件，也是最肥的），但是不知道去哪里找大学生。Google的影响力比较大，所以就挑了个头，先把这些开源项目的ideas登上去，让学生们挑，学生再把自己的简历投给Google，Google安排一个统一的时间由开源组织去选，选中的学生由Google撮合双方见面或不见面开发，主要是利用了学生在暑期的80天空闲时间，然后老板把钱付给Google，Google付给学生，中间40天的时候Google还要搞个&#8220;期中考试&#8221;。。。看了一下Eclipse的ideas，挺惊讶的，虽说这不是Eclipse项目发展的主流，但是也从一定程度上显示了Eclipse的不小野心。<br><br>其中我最感兴趣的是&#8220;Eclipse Open Office Integration&#8221;，它旨在把OpenOffice.org的组件嵌入到Eclipse的编辑器中去，而在此之前，Eclipse已能方便的嵌入Microsoft Office的组件了（得益于ActiveX）。这样的功能如果能实现，对我们平时的开发也是很有好处的。另一个我感兴趣的就是&#8220;Eclipse install based manager&#8221;，现在的RCP没有自己的安装程序，只是在Eclipse的帮助文档中有一篇制作RCP Install的指南，但这是远远不够的，我花在做安装程序上的时间太多了，不值得，因为这些都是共性的工作。除此之外，我还对&#8220;RCP real-time collaboration based upon ECF and Google Talk XMPP-based messaging service&#8221;感兴趣，如果Eclipse不做，我们也要做这样的功能。最后要提到的一个好玩的功能就是&#8220;NetBeans in Eclipse&#8221;，两种插件接口对Java阵营还是不利的，如果我为NetBeans编写的插件能够跑在Eclipse上的话，那NetBeans的新特性就会都变成Eclipse的新特性了（够自私了吧！）<br><br><span style="font-weight: bold;">5。RCP仍是无冕之王</span><br>Eclipse官网的黄金位置还是留给了RCP，RCP在全球还是有大量忠实粉丝的。不久前发现汇丰银行某个分行的CRM系统是基于RCP的（客户端），不久前又发现英国一个咨询公司专门提供RCP开发的咨询业务，不久前IBM正式进入公测阶段的Lotus Notes 8/Hannover也是基于RCP的，只是为了外观重写了Workbench，不久前。。。被人发现我们的软件也是基于RCP的，而且随时提供RCP方面的咨询和培训。<br><br><span style="font-weight: bold;">6。跟Mozilla结个亲家吧</span><br>忘了提Eclipse 3.3的又一大特性了，叫做&#8220;Moziila Everywhere&#8221;，是指在任何平台上都可以创建一个Browser控件但是使用Mozilla内核（及时该平台上没有安装Firefox）。这是怎么实现的呢？其实很简单，它要求你必须安装一个xulrunner，后者是Mozilla的全部内核，包括Gecko布局引擎、Javascript解析引擎、XUL解析引擎和XPCOM，其中每样东西都足够写一本书，有了这些，仅用XUL+Javascript就可以写出一个Firefox来，Eclipse洽是利用了这个特性，用Java连接XPCOM所以创建了一个Mozilla的Browser，但是没有任何行为，包括右键菜单。<br><br>这个Browser控件和缺省的Browser控件是不一样的，我们平时见到的缺省Browser控件，在Windows上用的是IE内核，在MacOSX上用的是Safari，在Linux上。。。不知道，所以它是最最简单的浏览器，不具备任何可以定制的功能，除了显示一张HTML页面外，没有任何用处。（你该不会想用Eclipse写一个傲游出来吧）<br><br>但是Mozilla内核的浏览器控件就不同了，它意味着如果程序员平时为Firefox写插件的形式，也可以被应用到RCP应用程序上来，设想一下我们拥有一个RCP+xulrunner的平台吧，RCP接收Java扩展，xulrunner接收xul和javascript扩展，那我们的平台——要么叫Fireclipse，要么叫Eclifox——就所向披靡了。即使不利用它的可扩展性，单单就是能保证在不同平台上提供对Web应用程序的一致性展现一条，就足够臭美的了，更可以用写Eclipse插件的形式来限定浏览器的行为。。。。。。唉，刚才是不是说过一个NetBeans in Eclipse啊？把那玩意扔了吧～～<br><br><span style="font-weight: bold;">总结。</span><br><br>活活，还真是好久没有写Blog了呢。本来只想谈谈Eclipse基金会的，没想到越说越多，连MacOSX、JSON、Google、Mozilla都说了个遍，是不是说了你的偶像什么坏话，我常干这种事，直接跟我联系吧，我愿意分享我的一切感受和看法。忙了，再聊！
<br><br><span style="font-style: italic;">下一个大泡泡</span><br style="font-style: italic;"><span style="font-style: italic;">（转载本文需注明出处：Brian Sun @ 爬树的泡泡[http://www.briansun.com]）</span>
<br><br>  <img src ="http://www.blogjava.net/briansun/aggbug/111709.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/briansun/" target="_blank">Brian Sun</a> 2007-04-18 18:53 <a href="http://www.blogjava.net/briansun/archive/2007/04/18/111709.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>Java 专业人士必备的书籍和网站列表</title><link>http://www.blogjava.net/briansun/archive/2007/04/14/110626.html</link><dc:creator>Brian Sun</dc:creator><author>Brian Sun</author><pubDate>Sat, 14 Apr 2007 05:14:00 GMT</pubDate><guid>http://www.blogjava.net/briansun/archive/2007/04/14/110626.html</guid><wfw:comment>http://www.blogjava.net/briansun/comments/110626.html</wfw:comment><comments>http://www.blogjava.net/briansun/archive/2007/04/14/110626.html#Feedback</comments><slash:comments>2</slash:comments><wfw:commentRss>http://www.blogjava.net/briansun/comments/commentRss/110626.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/briansun/services/trackbacks/110626.html</trackback:ping><description><![CDATA[<p>developerWorks里面一篇非常不错的文章，我在订阅邮件里发现的：</p>
<p><a  href="http://www.ibm.com/developerworks/cn/java/j-javares.html?ca=dwcn-newsletter-java" title="http://www.ibm.com/developerworks/cn/java/j-javares.html?ca=dwcn-newsletter-java" target="_blank">Java 专业人士必备的书籍和网站列表</a></p>
<p>摘要：</p>
<p><a name="N1005A">书籍</a></p>
<p><a name="N1005A">每个程序员都会有一些由于经常被当作专业资料参阅而磨坏的书。下列书籍应该是 Java 语言程序员的书架上必备的。书很贵，所以我有意将这份列表弄得很短，仅限于重要书籍。</a></p>
<p><a name="N10064">Thinking in Java (Bruce Eckel)</a></p>
<p><a  href="http://www.amazon.com/exec/obidos/ASIN/0131002872" target="_blank"><em>Thinking in Java, 3rd edition</em></a> （Bruce Eckel; Prentice Hall PTR，2002 年）<br>
<a  href="http://www.china-pub.com/computers/common/info.asp?id=24614" target="_blank"><em>Java 编程思想：第3版</em></a> （陈昊鹏 等译; 机械工业出版社，2005 年）<br>
Eckel 的书对于学习如何在 Java 语言环境中使用好面向对象技术极其实用。书中大量的代码样例解释了他所介绍的概念。文字出自一个并不认为
Java 技术总是正确答案的人，所以相当地实用。Eckel
具有多种语言的大量经验，还有用面向对象方式进行思考的扎实技能。本书将这些技能放到实用的 Java 语言环境中。他还在写一本新书，名为 <em>Thinking in Enterprise Java</em>。</p>
<p><a name="N10080">Effective Java (Joshua Bloch)</a></p>
<p><a  href="http://www.amazon.com/exec/obidos/ASIN/0201310058" target="_blank"> 					<em>Effective Java: Programming Language Guide</em> 				</a> （Joshua Bloch; Addison-Wesley，2001 年）<br>
<a  href="http://www.china-pub.com/computers/common/info.asp?id=8645" target="_blank"><em>Effective Java 中文版</em></a> （潘爱民 译; 机械工业出版社，2003 年）<br>
本书是理解优秀 Java 程序设计原则的最佳书籍。大多数材料从其他的 &#8220;学习 Java &#8221; 的书中根本找不到。例如，Bloch 书中关于覆盖 <code>equals()</code> 这一章是我读过的最好的参考资料之一。他也在书中包括了很实用的建议：用接口替代抽象类和灵活使用异常。Bloch 是 Sun 公司 Java 平台库的架构师，所以他透彻地了解这门语言。事实上，他编写了该语言中大量有用的库。本书必读！</p>
<p>。。。。。。</p>
<p>。。。。。。</p>
<p>。。。。。。</p><img src ="http://www.blogjava.net/briansun/aggbug/110626.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/briansun/" target="_blank">Brian Sun</a> 2007-04-14 13:14 <a href="http://www.blogjava.net/briansun/archive/2007/04/14/110626.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>芒果软件XMIND 2007</title><link>http://www.blogjava.net/briansun/archive/2007/01/16/94288.html</link><dc:creator>Brian Sun</dc:creator><author>Brian Sun</author><pubDate>Tue, 16 Jan 2007 11:36:00 GMT</pubDate><guid>http://www.blogjava.net/briansun/archive/2007/01/16/94288.html</guid><wfw:comment>http://www.blogjava.net/briansun/comments/94288.html</wfw:comment><comments>http://www.blogjava.net/briansun/archive/2007/01/16/94288.html#Feedback</comments><slash:comments>11</slash:comments><wfw:commentRss>http://www.blogjava.net/briansun/comments/commentRss/94288.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/briansun/services/trackbacks/94288.html</trackback:ping><description><![CDATA[
		<p>
				<strong>[什么是芒果软件？]</strong>
				<br />
芒果软件，全称“北京市朝阳区芒果软件研究所”，是依法成立的民办科技类非企业法人。。。。。。</p>
		<p>这个话怎么说的这么不顺啊，换种说法。芒果软件，是一群技术精英的名字，我们来自四面八方，为了一个共同的前途走到一起，开始了一款软件从创意、设计到开发、测试、上市、销售，以及未来将成为国产软件之骄傲的传奇之旅。。。。。。</p>
		<p>我们所说的这段软件，就是XMIND！它是第一款可视化思维工具，也是目前市场上唯一的同类产品。登陆我们的网站可以看到它的介绍和截图：<br /><a title="http://www.mango-software.com/" target="_blank" href="http://www.mango-software.com/">http://www.mango-software.com/</a><br />
以及免费下载beta版：<br /><a title="http://www.xmind.cn/" target="_blank" href="http://www.xmind.cn/">http://www.xmind.cn/</a></p>
		<p>
				<strong>[什么是可视化思维工具？]<br /></strong>很多管理咨询公司和培训公司，以及很多中学和大学的教师，他们在传授一类方法，或开设一门课程，题目可能是“如何提高你的工作效率”。
这类课程80％的内容是很无聊的，学员也不太喜欢，但是有20％的内容是激动人心的。我们发现这激动人心的提高工作效率的方法就是用形象的思维工具帮助思
维。比如很多管理咨询公司和培训公司会开设名为“<strong>思维导图</strong>”的课程，课上要求学员们用纸和笔把自己脑海中随时冒出来的创意随时记录下来。</p>
		<p>记录的方法是在纸的中央画一个椭圆，里面写上中心主题，从这里发散出去想，想到的内容标为分支主题，每个分支主题还可以再发散，字写在线上，线划到
哪儿都要多划一点，这样就促进了自己的思维，这种思维方式比写文章要快很多倍（如果你没试过是无法想象的快），很快你就写满了整张A3纸！</p>
		<p>即为别人培训又会做软件的我们就想到用软件来实现这一切！因为软件绘制思维导图，可以大大提高绘图制品的价值，不仅可以自己看，还可以与别人分享，
最重要的是即使修改。如果在纸上绘制的时候把一个分支错误的连接在了另一个分支的后面，就无法修改了，如果是重要的图，就必须重新绘制，但是软件就不怕
了。另外，软件还可以排版，或者将某个思维导图<strong>导出成Word/Powerpoint</strong>的格式，再进一步利用，这就延长了办公软件的流程，从用户脑子里想的到纸上打印的完全的连接了起来。</p>
		<p>作为补齐最后一公里的软件产品，可视化思维工具还是跟其它Office软件有很大的不同，首先，Word和Powerpoint几乎都是以线性的方式组织文字和内容的，这和人脑的结构有很大的不同，因为人类都是以<strong>发散的方式</strong>思
考问题的；其次，Word和Powerpoint在调整篇章结构上太繁琐也不直观，很多用户都反映，他们在写文章或制作幻灯片之前都先用XMIND列提
纲，以便于谋篇布局，然后再为每个分支填入内容，之后还可以持续优化篇章结构，完全确定了以后，再用XMIND导出成最终需要的格式，修改错别字和最后排
版。</p>
		<p>除了绘制思维导图以外，XMIND还包含了很多其它符合人类基本思维方式的图形，我们将这类图形统称为“<strong>思维图</strong>”。XMIND提供了在线更新的功能，XMIND的用户还可以从芒果软件的网站上源源不断的下载更多的思维图的种类。当然，我们只作最重要的，适合大多数人的，具有个性化的图形还是要靠用户自己用XMIND丰富的个性定制功能自己设计，并提取模版，相互交流。</p>
		<p>可视化思维工具的另一大类用途是与他人交流思想。我们有很多客户是大企业的销售经理，他们在向客户演示自己产品和服务的过程中引入了XMIND，并获得了很好的反馈效果。因为它的形状是最适合人脑思维的，所以能表达的信息也最多最精确，也最容易被别人接受。XMIND的<strong>图标库</strong>也为用户绘制的思维图提供了额外的亮点，图形+图标所具有的表达能力是非凡的。此外，咨询公司和培训公司还辅导学员们利用XMIND帮助记忆和会议记录。最后，XMIND可以将同一个主题的所有思维图<strong>整合在一个文件里</strong>，因为用户愿意将“晨会计划”、“晨会内容”、“参会人员”和“会议反馈”等主题放在一个文件里，便于发给自己的boss。</p>
		<p>上面这些就是可视化思维工具的主要功能，了解一下XMIND
2007就会发现它的功能还远远不只这些。芒果软件的宗旨就是为广大用户提供最适合思维的软件，而XMIND的宗旨就是整理您的思维、发掘您的潜意识、激
活您的创意灵感，最后，帮助您绘制漂亮的图形。让Google去搜索网络吧，我们搜索的是您的大脑！</p>
		<p>
				<strong>[谁将会是XMIND的用户？]<br /></strong>XMIND有两类大的用户群：</p>
		<p>1。高层经理、白领精英、办公室一族、政府公务员<br />
特征：每日工作用脑量很大，处在现代办公环境中，常常需要计划、决策、记录、创意、演示、与人交流等等，工作节奏很快，工作时间中使用电脑占一定比重。</p>
		<p>2。中学生、大学生、中学教师、大学教授<br />
特征：每日学习、工作用脑量很大，常常需要记录、总结、归纳、综合、交流等等，工作、学习繁忙，使用电脑占一定比重。
</p>
<img src ="http://www.blogjava.net/briansun/aggbug/94288.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/briansun/" target="_blank">Brian Sun</a> 2007-01-16 19:36 <a href="http://www.blogjava.net/briansun/archive/2007/01/16/94288.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>澄清关于芒果软件的几个问题</title><link>http://www.blogjava.net/briansun/archive/2006/09/24/71540.html</link><dc:creator>Brian Sun</dc:creator><author>Brian Sun</author><pubDate>Sun, 24 Sep 2006 03:27:00 GMT</pubDate><guid>http://www.blogjava.net/briansun/archive/2006/09/24/71540.html</guid><wfw:comment>http://www.blogjava.net/briansun/comments/71540.html</wfw:comment><comments>http://www.blogjava.net/briansun/archive/2006/09/24/71540.html#Feedback</comments><slash:comments>3</slash:comments><wfw:commentRss>http://www.blogjava.net/briansun/comments/commentRss/71540.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/briansun/services/trackbacks/71540.html</trackback:ping><description><![CDATA[
		<b>[名称和商标]</b>
		<br />
		<br />我们和芒果网不是一家，一个是“芒果软件”，一个是“芒果网”；一个是“Mango Software”，一个“MangoCity”，将来也不会有商标权力上的问题，请大家放心。我们的中文全称是“北京市朝阳区芒果软件研究所”，目前的项目研发代号是“Brainy”。<br /><br /><b>[不是汉化软件]</b><br /><br />我们不是MindManager的汉化版本，也不是其它国外软件引入国内的成果。我们是完全自己开发拥有自主知识产权的软件产品。<br /><br />说起MindManager，我们不得不说它是一个强大的竞争对手，它已经得到了我们全部的重视，芒果软件的战略层视MindManager犹如百事可乐看待可口可乐一样。我们的技术目标是比MindManager做的更专业，就芒果软件目前的实力来说，这个目标是可以实现的；我们的商业目标是首先在国内站稳脚跟，因为我们是国内第一家，同时在国际市场上分得MindManager的一杯羹，进而和它平起平坐，最后超过它的市场份额。但这个目标并不表明我们是先做国内市场后做国际市场的。<br /><br /><b>[15％的问题]</b><br /><br />我们的推广材料上说“以15％的成本为用户提供15％的解决方案”，导致了很多不必要的误解。其实国内很多企业都宣称他们的解决方案是“100％的”、“完全的”或者“全套的”，我们从心底反对这种说法，这是在欺骗消费者，目前为止人类还没有一种软件能满足消费者的100％需求哪怕这种需求只是一个方面。（任何一款汽车也不行）。我们的产品是面向商业用户和教育用户的，拿前者来说，一个商业用户在办公的过程中需要一个软件来帮忙他整理思路，这是他完全可以使用Brainy，但很有可能并不仅仅使用Brainy，他用Brainy快速记录脑海中所想到的信息，用Quicktime录下自己的声音，再用Firefox通过Google搜索自己需要的图片，把图片加入到用Brainy绘制的思维导图上，再导出成Powerpoint文件，经过修改以后交给领导。<br /><br />我们所说的15％成本，其实是在说为用户在思考问题的总成本降低了85％，很多企业在提高员工的办公效率方面投资不少，但收效甚微。而国外很多学者论证过，思维导图确实是符合人的思维模式一种图形，它的效果说是说不清的，用了才知道。此外还有一层含义，是说我们的产品在面市之后，价格会很便宜。<br /><br /><b>[“符合中国人思维”的问题]</b><br /><br />很多朋友发来消息说他们期待我们能推出“符合中国人思维”的思维导图软件，我们非常感谢这些朋友的关注，但我认为这种说法不妥。首先我们要研究一下中国人和外国人的思维方式是否有不同？如果有，那么不同在哪里？我不想长篇大论，但我想说中国人和外国人思维方式的不同，是在于我们的文化，而不是我们大脑的结构。思议这种差异在我们的“芒果可视化思维工具”里是体现不出来的。<br /><br /><b>[“技术狂人”问题]</b><br /><br />很多很热心的朋友担心我们作为一个企业的方向问题。事实上，我们不是由“技术狂人”组成的，（哈哈，大笑，作狂人状），我们是一些有想法有热情而又时刻叮嘱自己保持清醒的年轻人。作为我的Blog读者的你，应该清楚这一点。我们注重市场，我们是从去年上半年开始思考这个创业方案的，但是直到今年5月份才开始着手去做。在开始创业前的一年的时间里，我们都在思考，思考市场、思考客户、思考营销、思考人员管理、思考国外的软件行业、思考国内的同行、思考产品、思考渠道、思考销售模式、思考市场合作与活动，甚至思考定价和折扣！而后，我们决定去做！事实上，我们直到现在也不是很成熟，但是让我们成熟起来的唯一途径就是大胆去做，我们已经感觉比国内的很多同行都要成熟了。<br /><br />在广泛的和朋友共享我们的创业思路的过程中，我发现了有趣的现象。当我和技术精英介绍我们项目时，他们往往担心这个东西做好了以后卖不出去，而丝毫不会担心这个产品能否面市；而当我和软件销售人员聊这个项目时，他们往往会担心这个东西做不出来，而丝毫不会担心做出来了以后能否卖的掉。这可能就是领域思维吧，当每个人谈及自己很擅长的领域时，都对我们赞不绝口，但也都表示，对他们不擅长的领域，十分担心（幸好情况不是反过来的）。我非常感谢这些朋友，也请你们相信，我们不会让你们失望！<br /><br /><b>[“盗版软件”问题]</b><br /><br />国内软件行业的版权问题确实不容乐观，作为进入这个行业的创业者，我们丝毫不会粉饰太平，也不会掩饰我们对于这个问题的担心。事实上，我们要正视这个问题，盗版是个大问题。但是担心终究要转变成一个解决问题的思路，如果你不想转行的话。我们对待这个问题有一套完整的想法，那就是“战略上轻视它，战术上重视它”！什么？具体一点？那就请听我娓娓道来。<br /><br />从战略上讲，盗版软件并不可怕，著名的Microsoft软件公司，盗版横行，据说，全中国只有3％的微软软件是正版的，但是微软公司在中国区的利润仍然很高，是全球利润最高的一个地区。国内的金山软件，其金山词霸和金山毒霸两大产品线都同时是盗版猖狂和利润丰厚的。<br /><br />从战术上讲，微软和金山这样的产品型企业为什么会在盗版横行的今天才能挣到这么多钱呢？原因有三：其一是抓大客户，主动向大客户推销，并保证大客户不在使用盗版，多数大企业尤其是跨国企业是不愿意使用盗版软件的。有些中型企业如果已经在使用盗版了，那就说明他们需要我们的产品，再可以由销售人员以赠送培训或打折的形式将正版软件推销出去。如果对方仍然执意不听，那么就只能用律师函的形式警告之，综合起来，就是“以法律为依靠，以谈判为途径，以价格为手段”。<br /><br />其二是技术反盗版，矢志不渝。上面所提到的这些手段，如果没有技术支撑就毫无疑义，你无法知道谁在用盗版，甚至给盗版软件提供正版的服务，这些没有技术上不断的进步是很有可能发生的，在这个方面，有很多做的很好的第三方技术可以被我所用，比如在线激活等等。<br /><br />其三，是商业手段和技术手段的联合使用。比如正版软件带有大量的资源光盘，这使得盗版的产品体积非常大，不易传播，很多盗版商为解决这个问题会精简产品，这违背了很多用户的意愿，导致这些用户不得不去购买正版，金山词霸就是这个策略。再比如版本混淆，很多软件产品出很多版本，每年每个系列都再出一个，盗版商往往只盗版其中的一个版本，然后以欺骗用户的方式把这个版本以多个版本发放，这使得用户常常得不到自己想要的版本，只好购买。还有一个更高级的策略就是在线升级，因为不断的更新正版软件的鉴别方法，且在升级时必须检查软件的合法性，所以导致很多用户使用了盗版软件之后不能自动更新，杀毒软件厂商，多数都是这个办法。<br /><br /><b>[“通用软件和盒装软件”问题]</b><br /><br />当我在网上公开这个想法时，很多朋友，甚至是软件界的朋友，表现出了他们对“通用软件和盒装软件”的前途的不信任感，他们认为这样的产品可能没有出路。很高兴这些朋友能够提醒我们这个问题。当我在思考该如何回答他们时，我发现可能由于一种“恨屋及乌”的作用，他们真正的想法并不是这样，而应该这样表述：“如果一种软件，仅仅通过零售渠道来销售，那么他们是没有前途的”。我非常及其已经特别的支持这种观点，因为通用和盒装软件的销售如果只有一种渠道的话，确实不太好做，况且现在个人软件零售市场还相当不健全。但是如果将它错误的表述为“通用和盒装软件没有前途”，那就大错特错了，纵观现在的软件界哪个领域不是通用软件在打头阵？哪个领域不是盒装软件的利润率最高？哪个财富500强企业不是通用和盒装软件的客户？不用说国外的微软国内的金山，单举数据库的例子就可以了，DB2主要的利润源是“通用数据库”而主要的竞争对手是Oracle的什么什么i和微软的SQL Server。<br /><br /><br />芒果软件的泡泡<br /><br /><br /><img src ="http://www.blogjava.net/briansun/aggbug/71540.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/briansun/" target="_blank">Brian Sun</a> 2006-09-24 11:27 <a href="http://www.blogjava.net/briansun/archive/2006/09/24/71540.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>芒果软件实验室 诚揽人才</title><link>http://www.blogjava.net/briansun/archive/2006/09/09/68698.html</link><dc:creator>Brian Sun</dc:creator><author>Brian Sun</author><pubDate>Sat, 09 Sep 2006 04:34:00 GMT</pubDate><guid>http://www.blogjava.net/briansun/archive/2006/09/09/68698.html</guid><wfw:comment>http://www.blogjava.net/briansun/comments/68698.html</wfw:comment><comments>http://www.blogjava.net/briansun/archive/2006/09/09/68698.html#Feedback</comments><slash:comments>9</slash:comments><wfw:commentRss>http://www.blogjava.net/briansun/comments/commentRss/68698.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/briansun/services/trackbacks/68698.html</trackback:ping><description><![CDATA[
		<p>芒果软件实验室（Mango Software Labs）是国内首家从事可视化思维工具类软件开发的机构。我们由一群技术精英组成，致力于使用先进的软件技术帮助用户真正意义上提高生产率，以15%的成本为用户提供15%的解决方案。</p>
		<p>芒果软件实验室正在研发中的项目Brainy（利用盛行于欧美，风靡于全球的思维导图理论）将会成为未来人类离之不得的全脑思维伴侣，它利用计算机软件技术和全脑思维艺术将人们的大脑和思维带入一个积极、高效的全新领域，Brainy将会在人们日常办公和生活中帮助用户增强记忆、规划写作、促进团队合作和内部沟通，在客户演示、会议记录、个人计划、项目管理、青少年教育等方面更是发挥着不可估量的作用。</p>
		<p>Brainy不能取代任何Office 办公软件，却能和当前的Office紧密集成，成为办公软件生态环境中的一员，Brainy存在的目的是为了填补用户的大脑和办公软件制品之间的鸿沟。多数用户可以在五分钟之内上手，并在第一次试用之后就离之不得。尤其对于英文区国家的从小在这种氛围中长大的用户而言更是容易接受这种理念。也正因为如此，芒果软件实验室从成立之初就把国际市场当作最重要的市场来看待。</p>
		<p>目前Brainy仍在开发阶段，芒果软件实验室需要有理想有抱负有能力有信心的“四有”技术骨干和创业精英的加盟。我们以Eclipse RCP为产品的运行平台，以测试驱动为产品的开发过程，以大量开放标准和开源软件为降低产品成本的有效手段，以全球第一的思维导图软件为产品的战略目标。</p>
		<p>芒果软件实验室在技术上重视重构和复用，在经营上重视产品化和全球化，在管理上重视“团队综合能力”和敏捷开发，实验室还会定期聘请“武林高手”现身讲座，让每位员工每周都有培训的机会，每月都有培训别人的任务，定期参加Code Review，量身订做技术课程。</p>
		<p>思想为箭，芒果做弓。一群充满激情和个性的年轻人正试图通过他们的努力去改变人们的思维方式，乃至改变整个世界。</p>
		<p>加入我们，你一定会大开眼界！</p>
		<p>
				<br />公司主页：  <a href="http://www.mango-software.com">http://www.mango-software.com</a></p>
		<p>有意者请联系（邮件请包含个人简历）：<a href="mailto:hr.mangosoft@gmail.com">hr.mangosoft@gmail.com</a></p>（申请职位请注明信息来自BlogJava,将会得到更多的关注) <br /><br /><span class="tpc_content">招聘职位1:<br />【软件设计师：RCP方向】<br /><br />职位描述：<br />通过重用Eclipse组件搭建桌面应用程序，完成所有的设计要求，将产品的易用性提高到专业水准。全部代码使用Java5.0。（同时招全职/实习研究生）<br /><br />职位要求：<br />1。精通Eclipse RCP，Eclipse插件开发，SWT/JFace架构。<br />2。精通设计模式，熟练使用重构优化软件设计。<br /><br /><br />招聘职位2：<br />【软件设计师：ODF方向】<br /><br />职位描述：<br />担任Brainy的核心模型的主要开发工作、文件格式设计、导入导出等。全部代码使用Java5.0。（同时招全职/实习研究生）<br /><br />职位要求：<br />1。了解ODF。<br />2。精通JCE者优先。<br />3。精通设计模式，熟练使用重构优化软件设计。<br />4。熟练使用Eclipse开发环境，了解测试驱动开发的开发流程。<br /><br /><br />招聘职位3：<br />【Java程序员】<br /><br />职位描述：<br />担
任Brainy项目组的开发人员，从开发开始做起，逐渐参与设计、测试、需求等环节。全面认识并使用Java5.0、Eclipse3.2、
Graphical Editing Framework、Apache Ant、Jakarta
Commons、iText、TrueZip、BouncyCastle等开发平台和编程环境。适合立志在软件行业发展的同学。（同时招全职/实习研究
生）<br /><br />职位要求：<br />1。精通Java语言。<br />2。有绘图软件开发经验者优先。<br />3。有桌面应用程序开发经验者优先。<br />4。精通设计模式，熟练使用重构优化软件设计。<br />5。熟练使用Eclipse开发环境。<br />6。了解测试驱动开发的开发流程者优先。</span><br /><p> </p><img src ="http://www.blogjava.net/briansun/aggbug/68698.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/briansun/" target="_blank">Brian Sun</a> 2006-09-09 12:34 <a href="http://www.blogjava.net/briansun/archive/2006/09/09/68698.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>诚揽人才（北京）</title><link>http://www.blogjava.net/briansun/archive/2006/08/01/61224.html</link><dc:creator>Brian Sun</dc:creator><author>Brian Sun</author><pubDate>Tue, 01 Aug 2006 08:55:00 GMT</pubDate><guid>http://www.blogjava.net/briansun/archive/2006/08/01/61224.html</guid><wfw:comment>http://www.blogjava.net/briansun/comments/61224.html</wfw:comment><comments>http://www.blogjava.net/briansun/archive/2006/08/01/61224.html#Feedback</comments><slash:comments>4</slash:comments><wfw:commentRss>http://www.blogjava.net/briansun/comments/commentRss/61224.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/briansun/services/trackbacks/61224.html</trackback:ping><description><![CDATA[
		<br />北京，创业型软件公司，走商用化产品化路线，目前正致力于开发某商务软件套件，特别需要以下人才，有意者请联系：<br /><br />Brian Sun<br /> briansun.vip@gmail.com<br /> 13811410545<br /><br />邮件请包含个人简历，欢迎暑期实习。<br /><br /><b>【软件设计师：UI方向】</b><br />兼职全职均可。<br />要求：<br />1。了解什么是轻量组件架构，熟练使用其中的一个（最好是Swing或Draw2D）。<br />2。精通GEF者优先。<br />3。了解基本的图形学算法。<br />4。精通设计模式，熟练使用重构优化软件设计。<br />工作简介：<br />使用Draw2D编写一个类似GEF的100%MVC架构，并用该架构编写并维护一个编辑器。全部代码使用Java5.0。<br />需要人数：2人<br /><b><br />【软件设计师：RCP方向】</b><br />兼职全职均可。<br />要求：<br />1。精通Eclipse RCP，Eclipse插件开发，SWT/JFace架构。<br />2。精通设计模式，熟练使用重构优化软件设计。<br />工作简介：<br />通过重用Eclipse组件搭建桌面应用程序，完成所有的设计要求，将产品的易用性提高到专业水准。可能需要对插件进行分拆、替换或重写。全部代码使用Java5.0。<br />需要人数：2人<br /><br /><b>【软件工程师：Java方向】</b><br />兼职全职均可。<br />要求：<br />1。精通Java语言，具备一定的Java5.0知识。<br />2。精通设计模式，熟练使用重构优化软件设计。<br />3。熟练使用Eclipse开发环境，了解测试驱动开发的开发流程。<br />工作简介：<br />担任某桌面应用程序的主要开放工作。<br />需要人数：2人<br /><br /><img src ="http://www.blogjava.net/briansun/aggbug/61224.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/briansun/" target="_blank">Brian Sun</a> 2006-08-01 16:55 <a href="http://www.blogjava.net/briansun/archive/2006/08/01/61224.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>为茶进化</title><link>http://www.blogjava.net/briansun/archive/2006/08/01/61216.html</link><dc:creator>Brian Sun</dc:creator><author>Brian Sun</author><pubDate>Tue, 01 Aug 2006 08:16:00 GMT</pubDate><guid>http://www.blogjava.net/briansun/archive/2006/08/01/61216.html</guid><wfw:comment>http://www.blogjava.net/briansun/comments/61216.html</wfw:comment><comments>http://www.blogjava.net/briansun/archive/2006/08/01/61216.html#Feedback</comments><slash:comments>4</slash:comments><wfw:commentRss>http://www.blogjava.net/briansun/comments/commentRss/61216.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/briansun/services/trackbacks/61216.html</trackback:ping><description><![CDATA[我喜欢喝咖啡，但每周最多只能喝两杯，过量饮用总是导致身体不适，尤其是胃。一个医学界的朋友告诉我这是由于中国人的胃是为茶而进化的，西方人的胃是为咖啡而进化的，所以中国人不适合多喝咖啡。由于抱有个人感情色彩，我总是试图反对她的这种观点，但苦于没有合适的理由，最近，我终于想通了这个问题。中国人喝茶的历史不过几千年，在几千年的时间里迅速的进化一个器官，即使达尔文的进化论毫无毛病可挑，这也在数学概率上难以圆说。也许这个问题刚好相反，我的意思是，反过来想就对了。事实上，是中国人在几千年的茶叶种植中不断的精选和改良品种，使得茶叶总是在向味觉和营养两个方向上发展，是中国人创造了适合中国胃的茶叶。所以，进化了的是茶，而不是胃。<br /><br />当然，这只是我的一个猜测，因为我不是医学工作者，也不是进化论专家，所以对这个问题没有发言权，而我想说的真正主体是：软件。<br /><br />在过去的20年中，人们眼睁睁看着微软从一个小企业成长为软件帝国，很多人把这种变化归功于微软的商业技巧和蛮横的霸权主义，我对这一观点十分非常以及相当的赞同，但也该想清楚的是，全世界的人们不会在短短20年中进化到额头上有个“M”，就像老虎的额头上有个“王”一样。真实的情况应该是，忠实的用户调教出了微软，而不是微软培养了广大的用户群。成功的软件总是在人们心里最痒痒的地方狠狠挠了一下。<br /><br />很多M打头的软件在易用性方面有太多值得我们学习的细节了，我们完全有理由比微软做的更好那是因为我们站在巨人的肩膀上。例如我非常喜欢的IE7，尽管它在很多方面仍然不如Firefox，但在其它一些方面却很快将成为标准，比如合并在一起的前进后退按钮，会不会又是一个进化的结果呢？又会不会对其它软件的Undo/Redo功能产生影响呢？<br /><br />在软件开发领域亦是如此。比如很多软件都需要浏览的功能，其中多数软件会选择使用一个成熟的浏览器产品来达到这个功能，IE对大家说的一句话是：“请将我嵌入您的应用程序！”，而Firefox对大家说的一句话是：“请和我一起组建您的应用程序！”人们更容易接受哪一种呢？我们同样看到的是“为软件开发人员进化”和“让软件开发人员为我们进化”两种力量。<br /><br />请将我所提及的观点同“面向”分开，我拒绝说“面向用户”，因为这会导致将责任推给用户。我建议很多软件企业（尤其是那些正在为自身软件的易用性发愁的企业——比如：用友）将内部宣传的口号改为“为用户进化”，因为这是一个动态的概念，区别于“面向用户”；也是一个自主的概念，区别于“用户驱动”。<br /><br />也许全世界最应该得到我的这些建议的是Google。Google正企图从零开始创造另一个物种，也许我应该把它比喻成中式咖啡，在这个过程中，创新并不是最重要的，无论我们要谈论的是态度还是方法。要知道，用户一时的激情只能让你一夜暴富，却不能让你称王称帝。<br /><br /><img src ="http://www.blogjava.net/briansun/aggbug/61216.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/briansun/" target="_blank">Brian Sun</a> 2006-08-01 16:16 <a href="http://www.blogjava.net/briansun/archive/2006/08/01/61216.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>两件小事让我抓狂 之二：Google编程大赛疯狂掉线</title><link>http://www.blogjava.net/briansun/archive/2005/12/13/23587.html</link><dc:creator>Brian Sun</dc:creator><author>Brian Sun</author><pubDate>Tue, 13 Dec 2005 01:40:00 GMT</pubDate><guid>http://www.blogjava.net/briansun/archive/2005/12/13/23587.html</guid><wfw:comment>http://www.blogjava.net/briansun/comments/23587.html</wfw:comment><comments>http://www.blogjava.net/briansun/archive/2005/12/13/23587.html#Feedback</comments><slash:comments>33</slash:comments><wfw:commentRss>http://www.blogjava.net/briansun/comments/commentRss/23587.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/briansun/services/trackbacks/23587.html</trackback:ping><description><![CDATA[<P>订阅我Blog的人都知道，我小时候，编程竞赛是我的强项，这是我最引以为豪的两件事之一。尤其是“动态规划”的题目，我更是花了高一宝贵的一年去研究，并且已经多次证明我是全市（小城市）青少年中做的最好的。所以直到现在，我仍然对这类编程竞赛充满了自信。昨天和今天举行的“Google中国编程挑战赛”又让我兴奋了起来，我已经一年没这么兴奋了，说实话，我对进入Google工作不抱有什么希望，也没想过得了什么奖，只是希望能够爽一把，（倒是很想得到李开复博士的签名），就像一个游戏高手看到游戏挑战赛那样。<BR><BR>令人气氛的结果不说你们也能猜到，更可气还是态度问题，下面是我跟admin的对话：</P>
<P><EM><FONT color=#006400>briansun&gt; (To Admin) admin:我刚刚掉线的时候还剩3分钟，能否将着3分钟补回来<BR>briansun&gt; (To Admin) admin: 我已经完成了代码，但是在点Compile的时候掉线了<BR>visualage&gt; (From Admin) briansun: 报歉，不能。<BR>briansun&gt; (To Admin) admin: 我掉线的时候，系统自动log off，然后计时仍然在继续吗？<BR>visualage&gt; (From Admin) briansun: 是的。<BR>briansun&gt; (To Admin) admin: 那不是很不合理？<BR>visualage&gt; (From Admin) briansun: 我们认为这样才合理。<BR>briansun&gt; (To Admin) admin: 我后来又连续登陆了4～5次都没有成功才耽误了时间<BR>visualage&gt; (From Admin) briansun: 不然你不是可以登上来，看了题，下去做，做好再发上来？<BR>briansun&gt; (To Admin) admin: 你们为了杜绝这种情况就把一些水平高但是网络环境不好的人拒之门外？！<BR>visualage&gt; (From Admin) briansun: 首先，断线而导致来不及的人，比offline下去作弊再上来帖的人，肯定要少得多。<BR>visualage&gt; (From Admin) briansun: 其次，真正水平高的人，不会在快来不及的时候才交。<BR>briansun&gt; (To Admin) admin: 我能不能再做一次别的题目，用刚才那么多的时间？<BR>visualage&gt; (From Admin) briansun: 不可以。<BR>visualage&gt; (From Admin) briansun: 一个人只允许有一个账号。<BR>briansun&gt; (To Admin) admin: 难道公平和多少有关吗？？！！<BR>briansun&gt; (To Admin) admin: 真正水平高的人可以喝杯咖啡再来做题吧？<BR>visualage&gt; (From Admin) briansun: 真正的选手，相信不会在比赛进行当中浪费时间。<BR>briansun&gt; (To Admin) admin: 但是网络浪费了我的时间！<BR>briansun&gt; (To Admin) admin: 你们对网络质量不好的人一次机会都不给吗？<BR>briansun&gt; (To Admin) admin: 那我应该投诉Google还是TopCoder还是中国网通？<BR>visualage&gt; (From Admin) briansun: 投诉谁也没有用。<BR>briansun&gt; (To Admin) admin: 你是哪个公司的？员工号多少？我投诉你！</FONT></EM></P>
<P>之后他再也没有回复。技术问题已经使我很恼火了，居然还有态度问题！我还是上篇那句话，我可以驳倒他，但是却不能对这场比赛有任何影响，只能眼睁睁看着它继续沿着“不公平”的道路走下去。后来我看了一下论坛，多数人反映教育网容易掉线，看来有志向的大学生们是跟Google无缘了。</P>
<P>抓狂的泡泡<BR></P><img src ="http://www.blogjava.net/briansun/aggbug/23587.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/briansun/" target="_blank">Brian Sun</a> 2005-12-13 09:40 <a href="http://www.blogjava.net/briansun/archive/2005/12/13/23587.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>两件小事让我抓狂 之一：Mac OSX上没有可用的双拼</title><link>http://www.blogjava.net/briansun/archive/2005/12/13/23586.html</link><dc:creator>Brian Sun</dc:creator><author>Brian Sun</author><pubDate>Tue, 13 Dec 2005 01:35:00 GMT</pubDate><guid>http://www.blogjava.net/briansun/archive/2005/12/13/23586.html</guid><wfw:comment>http://www.blogjava.net/briansun/comments/23586.html</wfw:comment><comments>http://www.blogjava.net/briansun/archive/2005/12/13/23586.html#Feedback</comments><slash:comments>28</slash:comments><wfw:commentRss>http://www.blogjava.net/briansun/comments/commentRss/23586.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/briansun/services/trackbacks/23586.html</trackback:ping><description><![CDATA[<P>1995年我就看上了苹果电脑，但是没有钱，也没必要买，当时的苹果电脑还很难用，高层应用和PC有很大的差异，但是现在的Mac OSX已经很好用了，很多平时在PC上赖以生存的工具都有了Mac版。简单举两个例子，凡是跟Apache/Eclipse/Mozilla/Codehaus有关的产品一般都有Mac版，GNU的产品很多都有Mac版，Microsoft的产品很多都有Mac版，凡是Mac OSX上的字处理软件，多数都有导出成Word文档的选项，以前认为我的掌上电脑（PocketPC2003）没有同步软件，最近也找到一个叫做PocketMac的东东。唯独没有的，就是双拼输入法了！事实上，Mac OSX本身带有一个双拼输入法，但是不能改码表，有点输入法常识的人都知道，双拼不能改表等于没有，因为市面上流行的码表少说也有5～8个，无论你选择哪一个，基本上只有1/8～1/5的用户可以使用。</P>
<P>但是，最令我气氛的是，国内软件除了100%PureJava的外，几乎清一色没有Mac版，但是据苹果公司的数据看，中国的苹果电脑用户并不少，这是为什么？！起初我站在软件生产厂商的立场上，觉得应该“把有限的资源投入到最广泛的市场上去”，但是随着时间的流逝我越来越感觉到这是欺负人（当然也是欺负自己），为什么呢？我有三个理由：</P>
<P>1。把应用从Windows上转移到Mac OSX上非常简单。Mac OSX的架构看起来复杂，其实很简单，就是BSD+Step，你用FreeBSD+OpenStep就可以模拟一个了，上面有GCC，还有支持老式MacOS的API，要知道，MacOS跟Windows的相似程度要大于其它任何视窗系统。</P>
<P>2。拱手把市场让给别人。Mac OSX上没有金山词霸，我只好用Google工具栏的及时翻译；Mac OSX上没有QQ，我只好用Sinomac的isQ（其实大部分时间我用iChat，这是一个Mac OSX自带的聊天工具，因为支持Jabber，所以可以跟Google Talk的用户聊天）；Mac OSX上没有Maxthon，我只好把机会留给Firefox；Mac OSX上没有FlashGet，我只好下个iGetter并且一直在用试用版；Mac OSX上没有紫光拼音，我。。。我。。。我什么办法都没的想，因为老外不会去做拼音输入法。</P>
<P>3。态度问题。抱着激励国产软件的想法，我分别给QIM（一个很好的输入法）的作者和紫光拼音的支持人员发了邮件。前者给我回了邮件，说他不懂双拼所以不做，然后我又回了邮件，告诉了他双拼的概念，任何一个有输入法常识的人都知道，双拼只要在全拼上稍稍修改就可以了，如果QIM真的全部代码都是他写的话（或者只要他理解全部代码的话），做出这样的修改不到8个小时的工作量，可是我收到的回复邮件还是说“不做”，理由居然是“...完全依赖于输入的上下文关系...”。天哪，我简直不敢相信自己的眼睛，我开始担心起自己是否有编程的天赋了，为此我特地请了一位同事——他是拼音加加的创始人之一——证明了这种说法是站不住脚的。但是我没有再给他任何回复，人家毕竟是一个人在无偿的写一个软件，即使我能在技术上驳倒他也不能“要求”他做任何事情。我突然想起来很久之前老外曾经议论过免费软件有没有服务的问题，可惜这种争议在国内毫无动静，我的同事还笑我说“国产软件连收费的都没有服务，更不要说免费的了”。真的吗？我的心巴凉巴凉的。紫光华宇更是直接了当的说不做。</P>
<P>稍有一些编程常识的人都知道，从Windows移植到Mac OSX是很简单的，稍有一些输入法常识的人都知道，从全拼到双拼的改动是很小的，可是国内同行，你们在面对上面两个常识的时候，在想什么呢？？<BR><BR>抓狂的泡泡<BR></P><img src ="http://www.blogjava.net/briansun/aggbug/23586.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/briansun/" target="_blank">Brian Sun</a> 2005-12-13 09:35 <a href="http://www.blogjava.net/briansun/archive/2005/12/13/23586.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>平台相关性与平台无关性</title><link>http://www.blogjava.net/briansun/archive/2005/11/17/20177.html</link><dc:creator>Brian Sun</dc:creator><author>Brian Sun</author><pubDate>Thu, 17 Nov 2005 01:19:00 GMT</pubDate><guid>http://www.blogjava.net/briansun/archive/2005/11/17/20177.html</guid><wfw:comment>http://www.blogjava.net/briansun/comments/20177.html</wfw:comment><comments>http://www.blogjava.net/briansun/archive/2005/11/17/20177.html#Feedback</comments><slash:comments>10</slash:comments><wfw:commentRss>http://www.blogjava.net/briansun/comments/commentRss/20177.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/briansun/services/trackbacks/20177.html</trackback:ping><description><![CDATA[这是一篇写给初学者看的文章。在前一段时间的招聘软件设计师的过程中，我对每一个看似初学者的人都会问这个问题，“您觉得平台相关性和平台无关性哪个更好
一些”，呵呵（偷笑），其实这是唬人的，多数回答者都会顺着出题者假装的思路回答“我个人认为平台无关性比较好”，可是只要有点软件设计经验或是对这个问
题有所思考的人都知道其实这个问题不只两个标准答案。<br>
<br>
关于平台无关性，我不想说什么，说什么也没用。大量软件设计或软件架构以此来标榜自己的优秀和出众，其实这没什么，因为大部分平台无关性的工作不是由你来
做的。如果你正在写一个Java程序，并依照Sun的100% Pure
Java的要求来做，那么应该就是平台无关的，如果你正在写一个Eclipse应用或直接用SWT/JFace组合来写应用程序，那么也是平台无关的，如
果你喜欢C/C++，并在用wxWidget写应用程序，那么也是平台无关的，如果你实在是很牛，在依照OSGi的规范写代码，那么ok，你的程序已经可
以从微设备到大型机统统可以用。<br>
<br>
平台无关也是一个相对的概念，在多个操作系统上运行可以称为平台无关的，以往在多个不同品种的CPU上运行可以称为平台无关性，还有一件搞笑的事情，某个
公司出了一套系统，可以在Java和.NET两个平台上运行，但却只能依赖于Windows系统（因而只能依赖于x86芯片），居然还可以称平台无关性，
可见这个概念有多么混乱。我个人评价是不是平台无关的仅有一个标准，那就是——你有没有为平台无关做出贡献！如果你为了能在多个平台上跑出你的代码而做了
很多工作，那么你就可以称自己为平台无关的，而如果你仅仅依赖SWT工作，那就不能称自己为平台无关的。不过话又说回来，如果你把SWT包含在自己的软件
中，并为此出了该软件的多个版本（每个SWT的版本是一个发行包），那么你也可以称此为平台无关的，虽然这个贡献并非出自你手。<br>
<br>
平台无关也不见得总是个优点，很多系统为了坚持平台无关而牺牲了很多特性，或不必要的提高了成本。比如前几年很多系统原意搞WEB界面，导致了很多易用性
方面的问题，Cooper说Web使人机交互技术倒退了10年，的确如此。我还读过一段源码，大概是一个单机版个人软件的源码，令人惊奇的是，该软件很
小，却把很多笔墨花在了业务对象和JDBC访问层之间的一个“抽象数据存储层”，理由是便于将来移至非JDBC平台，天哪！会有多少用户有机会使用不支持
JDBC的数据库？？！！这种设计和下面一种设计是一样的效用：“为了让这段代码支持非OO语境，我决定整个软件只用一个类！”。这种追求可以用四个字来
表述就是：“过渡设计”或者“吃饱撑着”！<br>
<br>
相反，这个世界上有80％的软件是平台相关的，这没什么不能理解的。就像“民主和专制的TCO哪个高”这个问题的答案一样，如果我现在要招聘的是部门经理
或副总裁，我很可能会问这个问题。事实上是，在整个人类的发展历程中，总成本最低（即总效率最高）的几个“社会时期”，几乎全是专制，但如果你不假思索，你的
答案一定是民主！当然，平台相关也是相对的概念。<br>
<br>
说到这里，有兴趣的读者可能会说结合二者是最好的选择，我不喜欢这种说法，因为太辨证了，我喜欢的是首先考虑依赖于哪个框架，再找寻该框架的平台无关性，
如果没有必要，尽量不要为平台无关（实际上是一种优先级非常低的非功能性需求）做任何事情，但如果有必要且成本允许，再做少许考虑，最好还是能够重用开源
世界的产品。<br>
<br>
仍以OSGi为例，这个例子很好，它对Java语言本身（还不是面向对象的公共语义）非常依赖，直接依赖至VM的spec，当然也写了些代码以避开
ClassLoader的个性，即使如此，OSGi事实上实现了从微设备到大型机全套支持，借助Java的平台无关性，既没有易用性、性能和成本方面的丝
毫损失，也为上层平台提供了平台无关的环境。同样，为Mac
OSX设计的很多非常优秀的软件都没有考虑平台无关的问题，而是用在PC上再做一套的方式来解决，这些都是值得思考和借鉴的解决方案。<br>
<br>
<span style="color: rgb(128, 128, 128); font-weight: bold;">有点忙的泡泡</span><br>
<span style="color: rgb(128, 128, 128); font-weight: bold;">（转载本文需注明出处：Brian Sun @ 爬树的泡泡[http://www.briansun.com]）</span><br>
<br>
<br>
<img src ="http://www.blogjava.net/briansun/aggbug/20177.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/briansun/" target="_blank">Brian Sun</a> 2005-11-17 09:19 <a href="http://www.blogjava.net/briansun/archive/2005/11/17/20177.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>关于隐喻</title><link>http://www.blogjava.net/briansun/archive/2005/11/15/19925.html</link><dc:creator>Brian Sun</dc:creator><author>Brian Sun</author><pubDate>Tue, 15 Nov 2005 08:54:00 GMT</pubDate><guid>http://www.blogjava.net/briansun/archive/2005/11/15/19925.html</guid><wfw:comment>http://www.blogjava.net/briansun/comments/19925.html</wfw:comment><comments>http://www.blogjava.net/briansun/archive/2005/11/15/19925.html#Feedback</comments><slash:comments>8</slash:comments><wfw:commentRss>http://www.blogjava.net/briansun/comments/commentRss/19925.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/briansun/services/trackbacks/19925.html</trackback:ping><description><![CDATA[<p>重温2005年1月期的《个人电脑》，一篇文章引起了我的思考，这篇文章的思想是说虽然每种电子产品都努力成为未来时尚，但任何电子产品都不会成为
未来时尚，因为在它们被普及之前它们就已经被淘汰了。（我认为作者是这个意思，但如果不是，请原谅）。文章以iPod为例，iPod？我没用过，但是我身
边这位同事，正在使用。</p>
<p>事实上这个世界上所有绝对创新的产品——注意，是绝对创新——都是超前的，不易被人理解的，流行不流行都是它的表面现象，它的本质是颠覆了人们之前
的某种理念。历史证明这种创新很难成功，想要举出一个伟大的发明因不合时代要求而饱受磨难的例子非常容易，找个小学生就可以了；历史证明这种创新很难成
功，但iPod不是失败者中的一员；历史证明这种创新很难成功，除非。。。。。。</p>
<p>除非什么？先看看我常说到的三个例子。</p>
<p>iPod是人类历史上的一个歹怪的东西，它违反了人们之前对MP3播放器的要求，它既不轻也不小，没有击中人们对随身听的主流需求；但是iPod引
入了另一些优点。。。可以播放很久。。。你都不知道自己想听什么。。。华丽的外观。。。等等等等；事实是iPod取得了市场的胜利，传统MP3厂商推出了
大量模仿iPod的产品也丝毫未能撼动它的地位，iPod嘲笑别人“你们不了解客户的真正需求”，抨击iPod的人则说“iPod将用户导向了一个错误的
领域，用户是缺乏理性的，他们并不了解自己的需要”，这就像辩论赛的双方，正方说反方没有读懂辩题，反方则说正方在歪曲辩题。</p>
<p>另一个例子来自Google
Talk，现在我已经基本离不开它了，虽然在几个月前我曾扬言“聊天工具我只要QQ”。Talk的出现来自对传统及时通讯工具（IM，Instant
Message）和“因特网实时聊天”工具（IRC，Internet Realtime
Chat）的反叛，这些工具经过近10年的发展已经越来越趋向复杂和娱乐化，互联网上随处可见“QQ大战MSN”之类的帖子，评价它们娱乐功能之间的差
异，但是Talk却以简洁的外观和几乎可以称为“功能不全”的软件设计杀入市场。与前一个例子相比，Talk并未取得什么可以称道的成功，但它的成功是必
然的，我有我的理由。</p>
<p>问题出在哪里？为什么会有些违反市场原理的所谓绝对的或彻底的创新取得胜利了呢？问题场出在我们的意识上。这就好比你遇到一位美女，你把她跟老婆做
了一个简单的比较后发现她比老婆更性感，但没有老婆可爱贤惠，这时美女向你表达了爱慕之心，怎么办？哈哈。我用脚趾头想一下也知道会有两种结果发生，一种
是在犹豫痛苦了很久之后终于还是回到老婆的怀抱，让美女失望即使她取得过短暂的成功，另一种可能是和老婆之间产生了越来越多的隔阂（不知道这些隔阂是从哪
来的）最后“不得不”分手，然后在痛苦了一小段时间之后又找到了新的归宿。而我要表达的观点是，这两种结果产生于两个不同的隐喻。在前一种情况里，美女向
你示意的结果是你认为她可以成为你的老婆，也就是说，她的目的是老婆，她的竞争对手是老婆，你必须在她和老婆之间作出选择。而在后一种情况里，她为自己设
定的隐喻是“情人”，她的目的是成为你生活中的另一个角色，因此你很快就接近了她并在不经意间帮助她取得了最后的胜利。</p>
<p>这个例子足够夸张了吧？再看看前面两个例子，开头那篇文章引起了我的注意，因为作者的观点是iPod的隐喻并不是一个MP3随身听，而是一个晶体管
收音机的替代品。（做惊讶状）试想人们为什么听收音机，是为了随时随地可以听到已经录制好了的节目，这些节目包括多数具有听觉享受的声音内容，并可以随意
切换，而现代收音机的缺点是这些节目不能随意组织，有时还会被地理位置影响收听品质。iPod没有地理位置的影响，节目可以随意组织，（也可以
Shuffle），更重要的是，现在的互联网和BT下载等技术已经可以很方便的找到所以你喜欢的节目，除非你喜欢某个电台的DJ，或者喜欢打热线电话参加
互动游戏，否则iPod都可以胜任。此外，我们应该对网上可以下载的声音内容越来越丰富充满信心，我之前的一个室友一直以听mp3的评书为杀时间的主要方
式。</p>
<p>我已经离不开Talk了，自从我跟一个武大的MM常用Talk聊天之后，现在跟老婆也总是用Talk聊天，Talk的好处是轻磅，速度快，窗口小，
不占空间（桌面空间和内存空间），没有乱七八糟的提示和广告。与Gmail良好集成，最近还发现它的一个好处是使用开放协议，所以在我刚买的iBook上
没有Talk我还可以用Google帐号跟Talk用户聊天（用iChat），这样又充分利用了iChat的优点。上次见到dudu（很久了）的时候还谈
起Talk，很多人认为Talk的优点在于跟Gmail的良好集成，这意味着Talk存在一个很有竞争力的隐喻：“能聊天的邮件提醒器”。如果你大部分的
网络生活都跟Gmail联系在一起，那你真的会离不开它。</p>
<p>隐喻的魅力是可以让一个不易被人理解的创意变得易于被人接受，不理解不要紧，感情上的接受是最重要的。事实上，隐喻并不是对事物表面现象的某个概括
或总结，而是对事物本质的歪曲的描述。虽然歪曲，但毕竟是体现本质的。不仅不同的隐喻可以导致不同的后果，同一个隐喻也可以导致不同的后果。最初老师在课
上讲“菜单”，很多学生都笑，“此菜单非彼菜单也”。Windows中提到的主菜单有很多，每个窗口都有一个，优点是菜单的内容与窗体（甚至窗体的内容）
相关，在同一个桌面上可以看到主菜单的比较，缺点是带来了大量的视线转移，且存在菜单被遮蔽的可能性。Mac系统上的主菜单是全局唯一的，随当前激活的窗
体的改变而改变，优点是为不会出现用户“找菜单”的局面，缺点了降低了菜单在应用程序功能中的地位，好在多数用户在从“初级”向“中级”的转变中，对菜单
的依赖越来越少，对快捷键（Mac上称“键盘迅捷”）的依赖越来越多。<br><br><font color="#808080"><strong>泡泡很久不见</strong><br></font></p><img src ="http://www.blogjava.net/briansun/aggbug/19925.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/briansun/" target="_blank">Brian Sun</a> 2005-11-15 16:54 <a href="http://www.blogjava.net/briansun/archive/2005/11/15/19925.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>用例还是用案</title><link>http://www.blogjava.net/briansun/archive/2005/09/19/13397.html</link><dc:creator>Brian Sun</dc:creator><author>Brian Sun</author><pubDate>Mon, 19 Sep 2005 06:37:00 GMT</pubDate><guid>http://www.blogjava.net/briansun/archive/2005/09/19/13397.html</guid><wfw:comment>http://www.blogjava.net/briansun/comments/13397.html</wfw:comment><comments>http://www.blogjava.net/briansun/archive/2005/09/19/13397.html#Feedback</comments><slash:comments>7</slash:comments><wfw:commentRss>http://www.blogjava.net/briansun/comments/commentRss/13397.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/briansun/services/trackbacks/13397.html</trackback:ping><description><![CDATA[<P>首先要做个广告，UMLChina(<A href="http://www.umlchina.com">http://www.umlchina.com</A>)是一家致力于在国内普及UML工具和方法学的一家网站，UMLChina目前已经举办过17期公开课，第17期于上周六周日在北京举行，主讲是国内第一批该领域的先行者潘加宇，熟悉&lt;&lt;程序员&gt;&gt;的朋友们应该非常熟悉这个名字。我有幸去听了这次公开课，虽然课程的内容多数对我来说是很熟的了，但是课程的形式上还是让我感受到了一丝震惊，我已经很久没有认真听过课了（大三的时候我喜欢学校里几个教管理学的教授，挺的很认真，此后就再也没认真听过课了），但是这次为期两天的课程还是给我感觉吸取了很多能量。作为一个学生的观点，我认为能吸引学生是合格的老师的第一道门槛；作为一个老师（我偶尔也走上讲台），我认为一节课能让学生领悟到一个或两个道理就已经很了不起了，而老潘就是这种讲师。（本条广告不收费）</P>
<P>第二件事还是做广告。在上课的空余时间里，我看了&lt;&lt;UML Distilled&gt;&gt;这本书，最新的版本是第三版，里面涵盖了UML 2.0的主要内容，Martin Fowler的书我全买了，也全看了，每一本都是经典，没有一句废话。可是令我有些不爽的是这本书的翻译。这本书的翻译者和本书第二版的翻译者是同一个人，可能这位翻译者在翻译上一个版本的时候UML界的一些术语的译法还没有统一，所以用的词和我们后来看到的多数关于UML的主流文档和书籍中不太一样，为个人阅读带来了一些不便，这一版他还沿用了上一版的译法，可能是译者很满意于自己以前的作品的缘故吧。（本条广告也不收Martin Fowler的钱了）</P>
<P>最后一件事是想讨论一下这本书里的一个译法：译者把所有的Use Case都翻译成了“用案”，而不是我们闭着眼睛也能说出来的“用例”。事实上China-pub上曾经还有翻译成“用况”的，并且讨论也十分激烈。关于这个词的翻译我想了很多，（没有利用上课的时间想，呵呵），最后我还是觉得可能“用案”更贴切一些。我的理由是这样的：case一词在国内用的最多的地方一般都翻译为“案例”，主要出现领域是管理咨询业和大学教育，所以为了保持其字面意思，还是翻译成“用例”或“用案”比较好，至于“用况”，不容易让人联想起Case来，要知道技术翻译最重要的一点就是“隐喻”，任何翻译都应该保证“Use Case”和“Test Case”在本质上是一种东西，二者的差别应该体现在用途和形式上。就像男人和女人的本质都是人一样。如果Test Case能翻译成“测况”的话，那我就实在佩服这位译者的想象力和勇气了，因为“测况”很容易让人联想起“测试实况”。接下来比较“案”和“例”，因为案有书面表示的意味，与公文打叫道的工作常常被称为“文案”；而“例”既有依据的意思，又有规定的含义。我认为使用“用例”一词的译者认为用例既是一种依据也是一种规定，所以应该用“例”。但事实上使用Use Case一词的老外也许并不是这种看法，他们可能既不是想要依据，也不是想要规定（Specification），而仅仅是想要一种结构化的文档，该文档以定义角色和封装角色的目标为表现手法，很好的为需求的描述和特征的枚举提供了。所以，“案”更能表示其英文原意。而Test Case则可以翻译成“测案”，如果不舒服，就叫“测试案例”好了。下面附上&lt;&lt;国际标准汉语大词典&gt;&gt;对这两个字的分别解释。</P>
<P><FONT color=#006400>案<BR>1.长形的桌子或架起来代替桌子用的长木板：～子。～板。书～。条～。拍～而起。<BR>2.提出计划、方法和建议的文件或记录：档～。备～。议～。提～。方～。有～可查。～卷。～牍。<BR>3.事件，特指涉及法律问题的事件：惨～。血～。～件。～例。～犯。破～。<BR>4.古代有短脚盛食物的木托盘：举～齐眉（形容夫妻相敬）。</FONT></P>
<P><FONT color=#006400>例<BR>1.可以做依据的事物：～证。～题。举～。～句。～如。<BR>2.规定：～外（不按规定的，和一般情况不同的）。体～。凡～。条～。破～。发凡起～。<BR>3.按规定的，照成规进行的：～会。～假。～行公事。<BR>4.调查或统计时指合于某种条件的具有代表性的事情：事～。病～。案～。</FONT></P>
<P>我本人英语水平很烂（不是谦虚），所以对于翻译也没什么发言权，更不想跟技术翻译精英们叫板，这篇随笔仅是随便聊聊，弥补一下中秋之夜没有写blog的憾事罢了。<BR></P><img src ="http://www.blogjava.net/briansun/aggbug/13397.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/briansun/" target="_blank">Brian Sun</a> 2005-09-19 14:37 <a href="http://www.blogjava.net/briansun/archive/2005/09/19/13397.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>也谈天下归一</title><link>http://www.blogjava.net/briansun/archive/2005/09/02/11844.html</link><dc:creator>Brian Sun</dc:creator><author>Brian Sun</author><pubDate>Fri, 02 Sep 2005 09:23:00 GMT</pubDate><guid>http://www.blogjava.net/briansun/archive/2005/09/02/11844.html</guid><wfw:comment>http://www.blogjava.net/briansun/comments/11844.html</wfw:comment><comments>http://www.blogjava.net/briansun/archive/2005/09/02/11844.html#Feedback</comments><slash:comments>5</slash:comments><wfw:commentRss>http://www.blogjava.net/briansun/comments/commentRss/11844.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/briansun/services/trackbacks/11844.html</trackback:ping><description><![CDATA[还记得我的文章吗？http://www.blogjava.net/briansun/archive/2005/03/21/2274.html<br>
<br>
现在，有两件事情需要补充：<br>
1。我当时（3月份）的猜测已经得到证实，Borland已经宣布作为独立软件的JBuilder已经走到了它生命的尽头，下一个版本的JBuilder
（可能是2006，今年年底将发行Beta版）将建立在Eclipse的基础之上。也就是说作为Eclipse对头的JBuilder已不复存在，现在的
JBuilder将是以一组Eclipse的插件形式提供给它忠实的用户和粉丝的。<br>
<br>
2。BEA已经把AspectWerks贡献给AspectJ这个已经不是新闻了，但是直到今天我才意识到这一战略的真正含义！原本AspectJ由
IBM一手主导的情况已经被改变了（施乐已经交出了AspectJ整个开发小组，现在的领导人是IBM的Adrian
Colyer），现在的AspectJ是由IBM和BEA联合控制的产品。看看有关AspectJ
5的随便一篇报道吧，长期以来在AOP领域内的楚河汉界——语法方面和XML方面——转眼便成了一条通天大道！而AspectJ昔日的最大竞争对手今天也
手拉手肩并肩的走在了一起，就好像那些战火和硝烟只存在于日记中一样。<br>
<br>
2004年，AOP的创始人Kiczales曾有过一段访谈，大概介绍了AOP的标准化之路，其中给出了两条道路供世人选择：以AspectJ为标准，或
者，以AspectJ来制定标准，现在看来IBM和BEA已经代表人类作出了选择。想到这。。。。。。我真的无话可说了。<br>
<br>
而且，BEA的野心还不仅仅局限于此。“在开源的世界里，什么是贡献？”这个问题不好回答，但是下面这个问题要简单一些：“靠昆虫传媒的花为什么都要好看
一些？”BEA贡献出AspectWerks的代价是得到了整个AspectJ，并且它已经多次表示将在JRockit中全面支持AspectJ了！设想
一下这是什么样的局面吧，作为中间件巨头的BEA，现在已经具备了随时可以将它庞大的产品线全方位的平移到轻量级容器的路线上去了，因为它可以从虚拟机的
级别支持AOP，釜底抽薪式的对所有开源容器发起新一轮的剿匪运动！IBM怎么办？IBM也没办法啊，除了应招之外还能干什么，好在IBM的精力全在这方
面了，又有AspectJ的主控制权。再假想一下——最后一次假想，如果IBM和BEA联手转向轻量级容器。。。。。。宁可。。。不要让。。。漏网！——
嘘，小声点！<br>
<br>
写日记的泡泡<br>
<br>
<br>

<img src ="http://www.blogjava.net/briansun/aggbug/11844.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/briansun/" target="_blank">Brian Sun</a> 2005-09-02 17:23 <a href="http://www.blogjava.net/briansun/archive/2005/09/02/11844.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>关于AOP的七个猜想</title><link>http://www.blogjava.net/briansun/archive/2005/08/31/11634.html</link><dc:creator>Brian Sun</dc:creator><author>Brian Sun</author><pubDate>Wed, 31 Aug 2005 05:53:00 GMT</pubDate><guid>http://www.blogjava.net/briansun/archive/2005/08/31/11634.html</guid><wfw:comment>http://www.blogjava.net/briansun/comments/11634.html</wfw:comment><comments>http://www.blogjava.net/briansun/archive/2005/08/31/11634.html#Feedback</comments><slash:comments>3</slash:comments><wfw:commentRss>http://www.blogjava.net/briansun/comments/commentRss/11634.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/briansun/services/trackbacks/11634.html</trackback:ping><description><![CDATA[<P><STRONG><FONT color=#ff0000>1。随处可见猜想。<BR></FONT></STRONG>在未来的软件开发过程中，AOP将以一种基础编程能力的形式出现，与OOP共同发展，成为主流开发环境的一个组成部分。而目前为止，AOP只是作为一种开发工具、或运行时代码而存在。到了那个时候，可能没有哪个产品声称：“我使用了AOP”，因为没有哪个产品没有使用AOP，就像现在没有哪个产品没有使用OOP一样。就算你的源代码中没有应用到编程语言的AOP能力，你也可能调用了某个应用了AOP的基础库。事实上，AOP之父Kiczales认为AOP可能首先在操作系统上有一定规模的应用。</P>
<P><STRONG><FONT color=#ffa500>2。语言级猜想。</FONT></STRONG><BR>AOP的真正实现是在一个特定的语言基础上的。比如数年之后，人类开始普遍使用K语言（K是J的后一个字母），K语言在语言本身上就可以编织和横切。此时AOP才得到真正的成熟，因为程序员在编写代码时可能根本不知道自己用到的是曾经的OO还是现在的AO，只有了解K语言虚拟机构造和背后实现的人才知道。但是，可能由于人固有的思维方式的问题吧，AOP仍然不会比OOP要使用的更多，甚至有可能仍然是Kiczales所提到的15% Solution！但是，从语言的角度去实现AOP也许会给人类的编程观念带来巨大的变化，这种变化就像OO所带来的一样。</P>
<P><STRONG><FONT color=#ffff00><FONT color=#a52a2a>3。存在AOD/AOA猜想。</FONT><BR></FONT></STRONG>OOP对人类的影响远不如它的两个弟弟OOA/OOD，后两者已经为整个软件开发行业带来了一次意义深远的革命，它至少使得全世界开发团队的人数扩大了10倍，开发工具和平台的复杂程度增加了10倍，完成客户某些简单要求的成本降低了90%，唯一的遗憾的是，软件开发的效率几乎没有数量级上的变化（依据《没有银弹》）。既然存在AOP，我们猜想也会存在AOD/AOA，比如会存在面向方面的重构手段，面向方面的设计模式，面向方面的最佳实践，面向方面的过程管理，以及在UML的未来版本中看到为面向方向而专门做的改进，甚至添加一个新的UML图类型。当这些东西都产生的时候，AOP才真正发展到了鼎盛时期。</P>
<P><FONT color=#008000><STRONG>4。可执行用例猜想。</STRONG></FONT><BR>AOP是一个广泛适用的充满想象空间的新技术，但是目前人们对AOP的研究方向过于狭窄，大部分声称正在研究AOP的开源项目其实是把AOP当成一个辅助工具来使用，这些项目中又有相当一部分是在做企业开发环境下的容器，他们并没有针对AOP本身进行开发。事实上，依照Jacbson的说法，AOP将直接导致软件的开发分为两种形式——对模块的开发和对用例的开发，现在的用例仅仅是图纸，必须要转变为OO代码才能执行，但是一旦有了AOP，AOP可以直接依据用例的定义，将多个不同的模块（可能来自不同的开发单位）连接起来，形成方面，而方面本身是可以执行的（语言级猜想），所以用例也就不再是图纸而是可以执行的了。这对于以UML为核心的现代软件过程来说，是个极好的信号。</P>
<P><FONT color=#ffc0cb><STRONG><FONT color=#9acd32>5。标准化猜想。</FONT><BR></STRONG></FONT>OO的成功经验告诉我们，要想取得最后的胜利，就要一致对外，统一了内部的概念，剩下的争论就只有实现问题了。我个人认为，多数OOP语言在概念上都是一致的，这种概念被语言学称之为语义，多数OOP的语义来自Smalltalk和C++这些早期尝试者，少数来自Java这种在技术的成熟期涌现出的商业产品。AOP目前还面临着这个问题。业界对AOP的标准化过程有两个猜想，一是由AspectJ领头，各大AOP实现都以AspectJ的语义作为研究问题的基本用语，设计和实现沿用现在的思路；另一个猜想是由权威组织，（开源、商业、或全球研究组织），如Eclipse/IBM/OOPSLA等等拿出一个统一的AOP语义内核，所有AOP项目都以该内核为基础开发。Java虚拟机是前一种思路的成功案例，后者则以XML为代表。</P>
<P><STRONG><FONT color=#7fffd4><FONT color=#000080>6。全静态编织猜想。</FONT><BR></FONT></STRONG>下面讨论一个实际的技术问题。时下多数AOP项目采用的编织技术无外乎两种：静态编织和动态编织。前者是指在编译前（预编译期）、编译期、和编译后编织，后者是指在运行期编织。Kiczales认为虽然没有明显的技术缺陷，但动态编织可能会面临一些发展远景的问题，他称之为“软件的演化问题”。不知道我对大师观点的理解是不是准确，我认为由于被编织的代码是在变化（发展）中的，我们总是希望这种变化对编织本身的影响最小，这时静态编织面临的问题最多就是重新编译，而动态编织可能不会那么简单。此外，全静态编织会导致另一个优点——这听起来有点奇怪——就是能力较弱，因为全静态编织继承了OO语言本身的约束，比如Java的约束和.NET之CLR的约束等等，这对于更规范的使用开发利器是大有好处的。“应该对人类准备大规模应用的每一种新工具小心钳制。”</P>
<P><FONT color=#800080><STRONG>7。AOP的诞生之迷猜想。</STRONG></FONT><BR>Kiczales先生在从事AOP的研究和开发之前也曾接触过其它对OOP的改良研究，其中包括反射和元对象技术。事实上，心平气和的说，后两者的变通能力和灵活程度都在前者之上，但是正因为如此，语言学家们认为，这些技术并不能有效的改善OOP的弊端，甚至还有可能引狼入室，带来新的“狼人问题”。后来，当Kiczales发现AOP时，他明白这才是人们真正需要的，他认为他们抓住了问题的咽喉。时至今日，AOP的实现技术已经千姿百态，百家争鸣了，但是，AOP创立之初的种种想法也在这种百花争艳中渐渐被人们遗忘，现在利用反射、元对象技术以及种种双刃剑式的技术来实现AOP的想法已经像争抢参院席位一样争夺市场的认可，这是事物的发展还是理想的倒退？AOP何时才能回归它的本原？上天为它安排的命运究竟如何，我们拭目以待。<BR><BR>最近，我和我的几个朋友正在组织一批开源斗士们合作编写AOP.NET，这是一个开源软件，在博客园上可以看到部分有关该项目的消息。但是由于种种原因，我们对一些基本的问题还没有达成共识，本文来自我对AOP的一贯看法，也是我对社团里很多问题的一个集中性回答吧。</P>
<P>开源泡泡<BR>（转载本文需注明出处：Brian Sun @ 爬树的泡泡[http://www.blogjava.net/briansun]）<BR></P><img src ="http://www.blogjava.net/briansun/aggbug/11634.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/briansun/" target="_blank">Brian Sun</a> 2005-08-31 13:53 <a href="http://www.blogjava.net/briansun/archive/2005/08/31/11634.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>测试驱动开发全功略</title><link>http://www.blogjava.net/briansun/archive/2005/07/31/8813.html</link><dc:creator>Brian Sun</dc:creator><author>Brian Sun</author><pubDate>Sat, 30 Jul 2005 18:08:00 GMT</pubDate><guid>http://www.blogjava.net/briansun/archive/2005/07/31/8813.html</guid><wfw:comment>http://www.blogjava.net/briansun/comments/8813.html</wfw:comment><comments>http://www.blogjava.net/briansun/archive/2005/07/31/8813.html#Feedback</comments><slash:comments>19</slash:comments><wfw:commentRss>http://www.blogjava.net/briansun/comments/commentRss/8813.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/briansun/services/trackbacks/8813.html</trackback:ping><description><![CDATA[&nbsp;&nbsp;&nbsp;&nbsp; 摘要: {关键字}<br>测试驱动开发/Test Driven Development/TDD<br>测试用例/TestCase/TC<br>设计/Design<br>重构/Refactoring<br><br>{目录}<br>TDD的目标<br>TDD的优点<br>TDD的步骤<br>FAQ<br>Best Practise<br>关于单元测试<br>实例：Fibonacci数列<br>关于本文的写作<br>后记：Martin Fowler在中国<br>鸣谢<br><br>什么时候重构？<br>什么时候设计？<br>什么时候增加新的TestCase？<br>TestCase该怎么写？<br>TDD能帮助我消除Bug吗？<br>我该为一个Feature编写TestCase还是为一个类编写TestCase？<br>什么时候应该将全部测试都运行一遍？<br>什么时候改进一个TestCase？<br>。。。。。。<br><br>（转载本文需注明出处：Brian Sun @ 爬树的泡泡[http://www.briansun.com]）&nbsp;&nbsp;<a href='http://www.blogjava.net/briansun/archive/2005/07/31/8813.html'>阅读全文</a><img src ="http://www.blogjava.net/briansun/aggbug/8813.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/briansun/" target="_blank">Brian Sun</a> 2005-07-31 02:08 <a href="http://www.blogjava.net/briansun/archive/2005/07/31/8813.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>好书推荐&amp;lt&amp;lt About Face 2.0 &amp;gt&amp;gt</title><link>http://www.blogjava.net/briansun/archive/2005/07/29/8734.html</link><dc:creator>Brian Sun</dc:creator><author>Brian Sun</author><pubDate>Fri, 29 Jul 2005 05:29:00 GMT</pubDate><guid>http://www.blogjava.net/briansun/archive/2005/07/29/8734.html</guid><wfw:comment>http://www.blogjava.net/briansun/comments/8734.html</wfw:comment><comments>http://www.blogjava.net/briansun/archive/2005/07/29/8734.html#Feedback</comments><slash:comments>2</slash:comments><wfw:commentRss>http://www.blogjava.net/briansun/comments/commentRss/8734.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/briansun/services/trackbacks/8734.html</trackback:ping><description><![CDATA[<span style="font-weight: bold;">英文名：About Face 2.0 - The Essentials Of Interaction Design</span><br style="font-weight: bold;">
<span style="font-weight: bold;">中文名：软件观念革命——交互设计精髓</span><br>
<br style="font-weight: bold;"><span style="font-weight: bold;">
作者：Alan Cooper，Robert M. Reimann</span><br>
<br>
<span style="font-weight: bold;">泡泡的评价：</span><br>
本书第一版几乎引发了一张全球软件界的革命，然而这次革命的影响却由于种种原因未能在今天的多数软件中体现，这不是人类的悲哀，这是我们要为之奋斗的事
业。自从我们选择入了软件这一行，我们就有义务为用户提供经过出色设计的软件，可尽管如此，我们当中仍然有很多人根本不知道什么叫设计。本书的作者
Alan Cooper为微软拿到了为数不多的几个Jolt大奖中的一个——Visual
Basic2.0，也为我们提供了为数不多的几本好书中的一本——About
Face2.0。我们崇拜大师，并不因为他们是上帝，而是因为他们是上帝的布道者；我们渴望设计，并不因为设计代表一切，而是因为一切都依靠设计。书的扉
页上写着：“因为设计，所以出色”。<br>
<br>
<span style="font-weight: bold;">China-pub的简介：</span><br>
本书是一本由一位在交互设计前沿有着10年设计咨询经验及25年计算机工业界经验的卓越权威撰写的设计数字化产品行为的启蒙书。它探索了一个独特的设计领
域，即复杂系统行为的设计——特别是软件激活技术。本书论述一种具有革命意义的设计观念——人类驱动设计过程。
本书是一本难得的大师经典之作，应该是一本产品规划师、界面设计师以及可用性工程职业人员或者程序员都想得到的书。<br>
<br>
<span style="font-weight: bold;">目录：</span><br>
<br>
第一篇 了解你的用户<br>
<br>
&nbsp;&nbsp; &nbsp;第一部分 弥合差距<br>
&nbsp;&nbsp; &nbsp;1 目标导向设计<br>
&nbsp;&nbsp; &nbsp;2 实现模型和心智模型<br>
&nbsp;&nbsp; &nbsp;3 新手. 专家和中间用户<br>
&nbsp;&nbsp; &nbsp;4 理解用户：定性研究<br>
&nbsp;&nbsp; &nbsp;5 用户建模：人物角色和目标<br>
&nbsp;&nbsp; &nbsp;6 脚本提纲：将目标转换为设计<br>
&nbsp;&nbsp; &nbsp;7 综合好的设计：原理和模式<br>
<br>
第二篇 设计行为和形式<br>
<br>
&nbsp;&nbsp; &nbsp;第二部分 除去障碍，达到目标<br>
&nbsp;&nbsp; &nbsp;8 软件姿态<br>
&nbsp;&nbsp; &nbsp;9 和谐与流<br>
&nbsp;&nbsp; &nbsp;10 消除附加工作<br>
&nbsp;&nbsp; &nbsp;11 导航和调整<br>
&nbsp;&nbsp; &nbsp;12 理解撤销<br>
&nbsp;&nbsp; &nbsp;13 重新思考“ Files ”和“ Save ”<br>
<br>
&nbsp;&nbsp; &nbsp;第三部分 提供高效能和愉悦<br>
&nbsp;&nbsp; &nbsp;14 设计体贴的软件<br>
&nbsp;&nbsp; &nbsp;15 设计智能的软件<br>
&nbsp;&nbsp; &nbsp;16 改进数据检索<br>
&nbsp;&nbsp; &nbsp;17 改进数据输入<br>
&nbsp;&nbsp; &nbsp;18 为不同的需要进行设计<br>
<br>
&nbsp;&nbsp; &nbsp;第四部分 应用视觉设计原理<br>
&nbsp;&nbsp; &nbsp;19 外观设计<br>
&nbsp;&nbsp; &nbsp;20 隐喻. 习惯用法和启示<br>
<br>
第三篇 交互细节<br>
<br>
&nbsp;&nbsp; &nbsp;第五部分 鼠标和操作<br>
&nbsp;&nbsp; &nbsp;21 直接操作和定点设备<br>
&nbsp;&nbsp; &nbsp;22 选 择<br>
&nbsp;&nbsp; &nbsp;23 拖 放<br>
&nbsp;&nbsp; &nbsp;24 操作控件. 对象和连接<br>
<br>
&nbsp;&nbsp; &nbsp;第六部分 控件及其行为<br>
&nbsp;&nbsp; &nbsp;25 窗口行为<br>
&nbsp;&nbsp; &nbsp;26 使用控件<br>
&nbsp;&nbsp; &nbsp;27 菜单：教学向量<br>
&nbsp;&nbsp; &nbsp;28 使用菜单<br>
&nbsp;&nbsp; &nbsp;29 使用工具条和工具提示<br>
&nbsp;&nbsp; &nbsp;30 使用对话框<br>
&nbsp;&nbsp; &nbsp;31 对话框礼节<br>
&nbsp;&nbsp; &nbsp;32 创建更好的控件<br>
<br>
&nbsp;&nbsp; &nbsp;第七部分 与用户的交流<br>
&nbsp;&nbsp; &nbsp;33 消除错误<br>
&nbsp;&nbsp; &nbsp;34 通知和确认<br>
&nbsp;&nbsp; &nbsp;35 与用户的其他交流方式<br>
&nbsp;&nbsp; &nbsp;36 安装过程<br>
<br>
&nbsp;&nbsp; &nbsp;第八部分 超越桌面的设计<br>
&nbsp;&nbsp; &nbsp;37 Web 设计<br>
&nbsp;&nbsp; &nbsp;38 嵌入式系统的设计<br>
<br>
<img src ="http://www.blogjava.net/briansun/aggbug/8734.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/briansun/" target="_blank">Brian Sun</a> 2005-07-29 13:29 <a href="http://www.blogjava.net/briansun/archive/2005/07/29/8734.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>哪些是rup必须要有的制品</title><link>http://www.blogjava.net/briansun/archive/2005/07/22/8165.html</link><dc:creator>Brian Sun</dc:creator><author>Brian Sun</author><pubDate>Fri, 22 Jul 2005 01:46:00 GMT</pubDate><guid>http://www.blogjava.net/briansun/archive/2005/07/22/8165.html</guid><wfw:comment>http://www.blogjava.net/briansun/comments/8165.html</wfw:comment><comments>http://www.blogjava.net/briansun/archive/2005/07/22/8165.html#Feedback</comments><slash:comments>3</slash:comments><wfw:commentRss>http://www.blogjava.net/briansun/comments/commentRss/8165.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/briansun/services/trackbacks/8165.html</trackback:ping><description><![CDATA[<BR><SPAN style="FONT-WEIGHT: bold">1。项目概述</SPAN><BR>简单的说就是“WHAT IS”。向任何对该项目感兴趣的角色传达这些基本的必要的信息。<BR><BR style="FONT-WEIGHT: bold"><SPAN style="FONT-WEIGHT: bold">2。风险列表</SPAN><BR>以头脑风暴的方式列出项目可能遇到的所有风险。风险列表一定要是客观的，既不能推卸责任也不能表决心献殷勤，要实事求是。<BR><BR><SPAN style="FONT-WEIGHT: bold">3。用例</SPAN><BR>需求的规范表现形式。用例并不一定要用UML用例图来表示，但是颗粒度是用例最难以把握的问题之一。<BR><BR><SPAN style="FONT-WEIGHT: bold">4。设计图</SPAN><BR>通常用于总体设计，可以是UML图，也可以是CRC卡，还可以是更灵活的一些东西，视项目组成员的习惯和水平而定。<BR><BR><SPAN style="FONT-WEIGHT: bold">5。构建工具</SPAN><BR>如Ant脚本，目的是实现每日构建。<BR><BR><SPAN style="FONT-WEIGHT: bold">6。版本管理</SPAN><BR>悲观锁如VSS或乐观锁如CVS/SVN，都无所谓，关键是要能管理不同的分支和历史工作成果。<BR><BR><SPAN style="FONT-WEIGHT: bold">7。测试用例</SPAN><BR>按TDD的说法，测试用例应该打成包，随产品已经发布，这样在每次修改代码之后或发布一个新版本之前都可以确保之前的代码仍然是有效的。<BR><BR><SPAN style="FONT-WEIGHT: bold">8。产品</SPAN><BR>包括二进制发布包和所有导致该发布包的源代码或原始配置文件。<BR><BR><SPAN style="FONT-WEIGHT: bold">9。发布说明</SPAN><BR>简述这一版与上一版的不同。当然还要包括版权声明、其它商品的版权声明、和许可证。<BR><BR><SPAN style="FONT-WEIGHT: bold">10。开发计划和迭代计划</SPAN><BR>项目过程中产生的制品，为日后开发其它项目提供参考资料。<BR><BR>RUP泡泡<BR><BR><img src ="http://www.blogjava.net/briansun/aggbug/8165.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/briansun/" target="_blank">Brian Sun</a> 2005-07-22 09:46 <a href="http://www.blogjava.net/briansun/archive/2005/07/22/8165.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>体验经济在软件</title><link>http://www.blogjava.net/briansun/archive/2005/07/21/8095.html</link><dc:creator>Brian Sun</dc:creator><author>Brian Sun</author><pubDate>Thu, 21 Jul 2005 02:38:00 GMT</pubDate><guid>http://www.blogjava.net/briansun/archive/2005/07/21/8095.html</guid><wfw:comment>http://www.blogjava.net/briansun/comments/8095.html</wfw:comment><comments>http://www.blogjava.net/briansun/archive/2005/07/21/8095.html#Feedback</comments><slash:comments>9</slash:comments><wfw:commentRss>http://www.blogjava.net/briansun/comments/commentRss/8095.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/briansun/services/trackbacks/8095.html</trackback:ping><description><![CDATA[<P>近100年来美国经济学界和管理学界的主流理论和理论框架，都会或多或少的在其它领域的主流理论和理论框架中产生映射，这是很多主修经管专业的学生改行进入其它领域后总的心得。在下不才，也是其中一员，并且也有一点自己的心得。</P>
<P>最近十年管理学界对体验经济的理论层出不穷，形成理论界的一大热点。总的来说，体验经济是将未来的经济模式，同产品经济、商品经济和服务经济相区别，对这个概念不了解的朋友可以先看一个写在《体验经济》一书扉页上的这个案例：</P>
<P><FONT color=#008000>Rebecca的妈妈小时候过生日，Rebecca的奶奶自己亲手做蛋糕为她庆祝，她的原料比如奶油、鸡蛋、面粉等等都是从邻街的小店里面一美分一美分买来的。Rebecca小时候过生日，妈妈打电话给附近的一家蛋糕店，蛋糕店立即送来的美味可口的蛋糕，这样Rebecca可以请邻居家的小孩来过Party，这个蛋糕只要花十几美元。现在Rebecca的女儿过生日，Rebecca将整个生日交给Disney公司去办，公司的姐姐们带Rebecca的女儿和她的小伙伴们去城郊的一个小山坡野营。在那里，孩子们学会了自己搭帐篷，挤牛奶，采野生的葡萄酿酒，整理破旧的茅草屋。在一天的猎奇旅程之后，公司送每一位孩子回家，Rebecca付给了他们一张$146的支票。</FONT></P>
<P>尽管体验经济首先是在餐饮、旅游、娱乐、零售等行业首先发展并扩散开来，但是我相信，它迟早会在软件领域展露头角。我的这种想法由来已久，在最近一段时间里这个想法被激发，导致我写这篇文章，我认为体验经济至少应该在下面四个方面对软件界有所帮助：</P>
<P><FONT color=#ff0000><STRONG>1）近似帮助的导航。</STRONG></FONT><BR>如果你还没有下载Eclipse 3.1，那么你还不能真真了解我的意思。看看Eclipse的Million Downloads Challenge吧，3.1版正式版推出的第一天全球下载量就接近20万份，这绝不是宣传的效果，而是全世界的软件开发人员和关注软件界成长的人们共同的精神支柱。3.1版在易用性上又有大幅度的提高，随处可见的Html风格的说明信息，从一个对话框到另一个对话框的“超链接”，首选项的搜索与过滤，首选项的编辑导航（前进、后退等），FastView可以变成内嵌Frame，任意输入框里的工具条，任意输入框里的感叹号、问号和小红叉，等等等等，无一不在3.0版已经很“花里胡梢”的界面上再“锦上添花”。并且，知道内情的人都知道，这些对用户眼球产生极大刺激的小技量，对于Eclipse来说是多么的轻而易举。这么说吧，这些东西放在你的应用程序里面叫做“特性”，放在Eclipse里面叫做“对特性的应用”。</P>
<P><FONT color=#ffa500><STRONG>2）软件为什么不能用画的。<BR></STRONG></FONT>既然标准控件可以拖到窗体里变成代码，为什么用户不能用笔画一些代码出来呢？我想未来的软件应该会以某种“更自由”的方式向用户提供体验。比如，用户可以画一个圆作为输入框；用户可以画一条线来表示状态条；用户可以画一个图标或写一个单词，再和一个程序定义好的Action建立链接；用户可以画一个小人提供导航；用户可以规定什么样的状态用什么样的符号表示；用户还可以规定在哪里可以显示固定的及时帮助，什么时候可以显示浮动的及时帮助；最后，用户被要求画一个区域（可能是不规则的多边形）来把刚才画的那些东西装进入，这个区域就是我们所说的窗体（想想很多播放器都支持不规则的图形作为skin）。</P>
<P><FONT color=#008000><STRONG>3）同时面对新手和熟练工人。</STRONG><BR></FONT>关于气泡式的及时帮助，业界有很多的争议，这些争议大都来自不同领域的不同需求。比如一个面向客户的财务系统，开发者可能希望随时随地都能让使用者知道下一步该怎么办（或者这一步该怎么办），可是一个面向企业内部的财务系统，投资商则更愿意花费少许培训费用来使该系统的使用者更加熟练，这些费用可能会比在软件中加入大量的帮助更为经济，更重要的是，去除这些气泡往往会提高使用者的效率，给企业带来更多的好处。所以体验经济要求我们的软件理念能在两种模式之间自由切换，甚至可能会同时体现在同一个系统上，比如某个在线游戏，新手希望能随时随地得到提示，而老玩家则希望在某个选项页上关掉这些提示——以速度取胜。</P>
<P><FONT color=#800080><STRONG>4）功能微调和界面微调。</STRONG></FONT><BR>多数软件已经开始向Extendable转变了，少数精英已经开始向Pluginable（这是我自己造的词，被画上红线别怪我，呵呵）转变了。有图形处理和媒体制作软件，如Photoshop、Fireworks、Flash，有开发工具IDE，如Eclipse、SharpDevelop，有浏览器如Firefox，有小工具如我正在使用的EmEditor等等，在SourceForge的排行榜第一名上待了很久不愿下来的Azureus - Java BitTorrent Client也是Pluginable的。更有令人惊奇的，有一个叫Java Plugin Framework(JPF)的项目可以为所有Java软件增加Pluginable的能力，这个项目吸收了Eclipse的思想，但是比Eclipse的插件平台更通用，更具扩展性，也更严格。至于界面上的微调，Eclipse也为我们作出了榜样，它可以允许成千上万个View和Editor并存在同一个窗体里，并提供了最大化、最小化、FastView、内部Frame等多种展现形式，（意思是说它们不会太挤），甚至可以在界面上搜索和过滤这些parts，这样做的主要目的是将用户工作中能遇到的交互事件划分成更细小的颗粒。我认为未来的软件能让用户在更小的颗粒度上调整UI，比如某个用户会在用软件时自言自语：“这个的Label我不喜欢，我要变成Icon；那里有个Table太繁琐了，换个饼图看看；哦，对了，这里有个讨厌的文字框，小样儿，我早就看你不爽了，干掉，直接写进log吧！”</P>
<P>在本文的最后我还要告诉大家的是，虽然很多软件用XP结尾来标称自己是“用户体验版”，比如Windows xp和Office xp，但是我仍然认为体验经济的时代要求未能很好的表现在当前的主流应用中，无论是操作系统、办公软件、在线应用，或者ERP，但是我们已经可以在一些游戏、及时消息软件或大师作品中看到一点希望。重复本文开头时的论点，我相信体验经济在软件的时代即将到来，如果您手上正在做的软件没有考虑这一点，那么还是请考虑一下吧，我们都不希望在这次浪潮中国产软件再次落后，如果要我给出一个理由来支撑我的观点，那我只想说——这是经济学的规律。<BR><BR>（转载本文需注明出处：Brian Sun @ 爬树的泡泡[http://www.blogjava.net/briansun]）<BR></P><img src ="http://www.blogjava.net/briansun/aggbug/8095.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/briansun/" target="_blank">Brian Sun</a> 2005-07-21 10:38 <a href="http://www.blogjava.net/briansun/archive/2005/07/21/8095.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>NXUnit 中文说明</title><link>http://www.blogjava.net/briansun/archive/2005/07/20/8028.html</link><dc:creator>Brian Sun</dc:creator><author>Brian Sun</author><pubDate>Wed, 20 Jul 2005 02:09:00 GMT</pubDate><guid>http://www.blogjava.net/briansun/archive/2005/07/20/8028.html</guid><wfw:comment>http://www.blogjava.net/briansun/comments/8028.html</wfw:comment><comments>http://www.blogjava.net/briansun/archive/2005/07/20/8028.html#Feedback</comments><slash:comments>5</slash:comments><wfw:commentRss>http://www.blogjava.net/briansun/comments/commentRss/8028.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/briansun/services/trackbacks/8028.html</trackback:ping><description><![CDATA[<a href="http://nxunit.sourceforge.net">NXUnit</a>是一个基于.NET
Framework的具有NUnit风格的XML单元测试框架。它是对NUnit的一个扩展，使你可以简单的在XML应用程序中加入断言，使你可以集中精
力在你的XML应用程序中的业务逻辑，使你提升测试驱动开发(TDD)的技巧，使你可以直接比较两个XML字符串或流，或者断言它们相等，就像使用
xUnit断言两个整数是否相等一样简单。如果没有NXUnit，你就必须把注意力集中在XML字符串中的空格、空节点、空属性、节点序、属性序、注释等
等。在某些方面，NXUnit有些像XmlUnit。<br>
<br>
NXUnit的当前版本是2005年7月的<a href="http://www.sourceforge.net/projects/nxunit">NXUnit 1.0rc1</a>，下面是该版本的8个特性，这些特性你都可以在XMLAssert类中找到相应的方法：<br>
1。断言两个XML输入是否相等。<br>
2。比较两个XML输入并找出它们的不同点。<br>
3。断言两个XML输入的XML定义是否相等。<br>
4。断言两个XML输入的文档类型是否相等。<br>
5。断言一个XML输入是否有效。<br>
6。断言一个XPath表达式在一个XML输入上执行返回的值是否是期望值。<br>
7。断言一个XPath表达式在一个XML输入上是否存在。<br>
8。断言一个XML输入是否包含另一个XML输入。<br>
<br>
并且，你可以改变一个XMLAssert实例的属性来配置一个断言或比较，目的在于：<br>
1。忽略节点和属性名称中的大小写。<br>
2。忽略XML注释。<br>
3。忽略XML定义或文档类型。<br>
4。忽略空的节点或属性。<br>
5。忽略节点和属性的顺序。<br>
6。忽略不重要的空白。<br>
<br>
<img src ="http://www.blogjava.net/briansun/aggbug/8028.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/briansun/" target="_blank">Brian Sun</a> 2005-07-20 10:09 <a href="http://www.blogjava.net/briansun/archive/2005/07/20/8028.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>BlogJava的开源软件：NXUnit</title><link>http://www.blogjava.net/briansun/archive/2005/07/15/7765.html</link><dc:creator>Brian Sun</dc:creator><author>Brian Sun</author><pubDate>Fri, 15 Jul 2005 05:22:00 GMT</pubDate><guid>http://www.blogjava.net/briansun/archive/2005/07/15/7765.html</guid><wfw:comment>http://www.blogjava.net/briansun/comments/7765.html</wfw:comment><comments>http://www.blogjava.net/briansun/archive/2005/07/15/7765.html#Feedback</comments><slash:comments>2</slash:comments><wfw:commentRss>http://www.blogjava.net/briansun/comments/commentRss/7765.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/briansun/services/trackbacks/7765.html</trackback:ping><description><![CDATA[<P><FONT face="Courier New" size=5><STRONG>What is NXUnit?</STRONG></FONT></P>
<P><A href="http://nxunit.sourceforge.net/">NXUnit</A> is a NUnit -style unit testing framework about XML for .NET Framework. It is an extension to NUnit. It brings you the ability to do unit testing easily in XML applications. It helps you to concentrate on business logic of your XML application and improve your Test Driven Development(TDD) technics. You can directly compare one XML string or stream with another, er assert that they are equal, just like doing the same thing to two integers using xUnit. But without NXUnit, you must pay attention to whitespaces in XML strings, empty elements or attributes, unimportant order of elements or attributes, unneccessary comments and so on. It's similar with XmlUnit in some aspects.</P>
<P><FONT face="Courier New" size=5><STRONG>Features</STRONG></FONT></P>
<P>The current version is <A href="http://www.sourceforge.net/projects/nxunit">NXUnit 1.0rc1, July 2005</A>. The following is the 8 features of this version, which you can find in the facade class XMLAssert:</P>
<P>&nbsp;&nbsp;&nbsp; * Assert that two XML inputs are equal.<BR>&nbsp;&nbsp;&nbsp; * Compare two XML inputs and find all differences between them.<BR>&nbsp;&nbsp;&nbsp; * Assert that declarations of two XML inputs are equal.<BR>&nbsp;&nbsp;&nbsp; * Assert that document types of two XML inputs are equal.<BR>&nbsp;&nbsp;&nbsp; * Assert the validity of an XML input.<BR>&nbsp;&nbsp;&nbsp; * Assert that the evaluation of an XPath expression on an XML input will return the expected value.<BR>&nbsp;&nbsp;&nbsp; * Assert that an XPath expression exists for an XML input.<BR>&nbsp;&nbsp;&nbsp; * Assert that an XML input is included by another. </P>
<P>And you can change the properties of an instance of XMLAssert before an assertion or comparition, in order to:</P>
<P>&nbsp;&nbsp;&nbsp; * Ignore the case of the elements' and attributes' names<BR>&nbsp;&nbsp;&nbsp; * Ignore XML comments<BR>&nbsp;&nbsp;&nbsp; * Ignore XML declarations and document types of both inputs<BR>&nbsp;&nbsp;&nbsp; * Ignore empty elements and attributes<BR>&nbsp;&nbsp;&nbsp; * Ignore orders of elements and attributes<BR>&nbsp;&nbsp;&nbsp; * Ignore unimportant whitespaces</P>
<P><FONT face="Courier New" size=5><STRONG>Sample<BR></STRONG><FONT size=3><FONT size=2><BR></P>
<DIV style="BORDER-RIGHT: windowtext 0.5pt solid; PADDING-RIGHT: 5.4pt; BORDER-TOP: windowtext 0.5pt solid; PADDING-LEFT: 5.4pt; BACKGROUND: #e6e6e6; PADDING-BOTTOM: 4px; BORDER-LEFT: windowtext 0.5pt solid; WIDTH: 98%; WORD-BREAK: break-all; PADDING-TOP: 4px; BORDER-BOTTOM: windowtext 0.5pt solid">
<DIV><SPAN style="COLOR: #008080">&nbsp;1</SPAN><IMG src="http://www.blogjava.net/images/OutliningIndicators/None.gif" align=top><SPAN style="COLOR: #000000">&nbsp;&nbsp;&nbsp;&nbsp;</SPAN><SPAN style="COLOR: #0000ff">using</SPAN><SPAN style="COLOR: #000000">&nbsp;System;<BR></SPAN><SPAN style="COLOR: #008080">&nbsp;2</SPAN><SPAN style="COLOR: #000000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/None.gif" align=top>&nbsp;&nbsp;&nbsp;&nbsp;</SPAN><SPAN style="COLOR: #0000ff">using</SPAN><SPAN style="COLOR: #000000">&nbsp;System.IO;<BR></SPAN><SPAN style="COLOR: #008080">&nbsp;3</SPAN><SPAN style="COLOR: #000000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/None.gif" align=top>&nbsp;&nbsp;&nbsp;&nbsp;</SPAN><SPAN style="COLOR: #0000ff">using</SPAN><SPAN style="COLOR: #000000">&nbsp;System.Xml;<BR></SPAN><SPAN style="COLOR: #008080">&nbsp;4</SPAN><SPAN style="COLOR: #000000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/None.gif" align=top>&nbsp;&nbsp;&nbsp;&nbsp;</SPAN><SPAN style="COLOR: #0000ff">using</SPAN><SPAN style="COLOR: #000000">&nbsp;NUnit.Framework;<BR></SPAN><SPAN style="COLOR: #008080">&nbsp;5</SPAN><SPAN style="COLOR: #000000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/None.gif" align=top>&nbsp;&nbsp;&nbsp;&nbsp;</SPAN><SPAN style="COLOR: #0000ff">using</SPAN><SPAN style="COLOR: #000000">&nbsp;NXUnit.Framework;<BR></SPAN><SPAN style="COLOR: #008080">&nbsp;6</SPAN><SPAN style="COLOR: #000000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/None.gif" align=top><BR></SPAN><SPAN style="COLOR: #008080">&nbsp;7</SPAN><SPAN style="COLOR: #000000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/None.gif" align=top><BR></SPAN><SPAN style="COLOR: #008080">&nbsp;8</SPAN><SPAN style="COLOR: #000000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/None.gif" align=top>&nbsp;&nbsp;&nbsp;&nbsp;[TestFixture]<BR></SPAN><SPAN style="COLOR: #008080">&nbsp;9</SPAN><SPAN style="COLOR: #000000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/None.gif" align=top>&nbsp;&nbsp;&nbsp;&nbsp;</SPAN><SPAN style="COLOR: #0000ff">public</SPAN><SPAN style="COLOR: #000000">&nbsp;</SPAN><SPAN style="COLOR: #0000ff">class</SPAN><SPAN style="COLOR: #000000">&nbsp;Sample<BR></SPAN><SPAN style="COLOR: #008080">10</SPAN><SPAN style="COLOR: #000000"><IMG id=Codehighlighter1_164_2392_Open_Image onclick="this.style.display='none'; Codehighlighter1_164_2392_Open_Text.style.display='none'; Codehighlighter1_164_2392_Closed_Image.style.display='inline'; Codehighlighter1_164_2392_Closed_Text.style.display='inline';" src="http://www.blogjava.net/images/OutliningIndicators/ExpandedBlockStart.gif" align=top><IMG id=Codehighlighter1_164_2392_Closed_Image style="DISPLAY: none" onclick="this.style.display='none'; Codehighlighter1_164_2392_Closed_Text.style.display='none'; Codehighlighter1_164_2392_Open_Image.style.display='inline'; Codehighlighter1_164_2392_Open_Text.style.display='inline';" src="http://www.blogjava.net/images/OutliningIndicators/ContractedBlock.gif" align=top>&nbsp;&nbsp;&nbsp;&nbsp;</SPAN><SPAN id=Codehighlighter1_164_2392_Closed_Text style="BORDER-RIGHT: #808080 1px solid; BORDER-TOP: #808080 1px solid; DISPLAY: none; BORDER-LEFT: #808080 1px solid; BORDER-BOTTOM: #808080 1px solid; BACKGROUND-COLOR: #ffffff"><IMG src="http://www.blogjava.net/images/dot.gif"></SPAN><SPAN id=Codehighlighter1_164_2392_Open_Text><SPAN style="COLOR: #000000">{<BR></SPAN><SPAN style="COLOR: #008080">11</SPAN><SPAN style="COLOR: #000000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/InBlock.gif" align=top>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</SPAN><SPAN style="COLOR: #0000ff">private</SPAN><SPAN style="COLOR: #000000">&nbsp;XMLAssert&nbsp;xa;<BR></SPAN><SPAN style="COLOR: #008080">12</SPAN><SPAN style="COLOR: #000000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/InBlock.gif" align=top><BR></SPAN><SPAN style="COLOR: #008080">13</SPAN><SPAN style="COLOR: #000000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/InBlock.gif" align=top>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;[SetUp]<BR></SPAN><SPAN style="COLOR: #008080">14</SPAN><SPAN style="COLOR: #000000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/InBlock.gif" align=top>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</SPAN><SPAN style="COLOR: #0000ff">public</SPAN><SPAN style="COLOR: #000000">&nbsp;</SPAN><SPAN style="COLOR: #0000ff">void</SPAN><SPAN style="COLOR: #000000">&nbsp;Init()<BR></SPAN><SPAN style="COLOR: #008080">15</SPAN><SPAN style="COLOR: #000000"><IMG id=Codehighlighter1_248_303_Open_Image onclick="this.style.display='none'; Codehighlighter1_248_303_Open_Text.style.display='none'; Codehighlighter1_248_303_Closed_Image.style.display='inline'; Codehighlighter1_248_303_Closed_Text.style.display='inline';" src="http://www.blogjava.net/images/OutliningIndicators/ExpandedSubBlockStart.gif" align=top><IMG id=Codehighlighter1_248_303_Closed_Image style="DISPLAY: none" onclick="this.style.display='none'; Codehighlighter1_248_303_Closed_Text.style.display='none'; Codehighlighter1_248_303_Open_Image.style.display='inline'; Codehighlighter1_248_303_Open_Text.style.display='inline';" src="http://www.blogjava.net/images/OutliningIndicators/ContractedSubBlock.gif" align=top>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</SPAN><SPAN id=Codehighlighter1_248_303_Closed_Text style="BORDER-RIGHT: #808080 1px solid; BORDER-TOP: #808080 1px solid; DISPLAY: none; BORDER-LEFT: #808080 1px solid; BORDER-BOTTOM: #808080 1px solid; BACKGROUND-COLOR: #ffffff"><IMG src="http://www.blogjava.net/images/dot.gif"></SPAN><SPAN id=Codehighlighter1_248_303_Open_Text><SPAN style="COLOR: #000000">{<BR></SPAN><SPAN style="COLOR: #008080">16</SPAN><SPAN style="COLOR: #000000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/InBlock.gif" align=top>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;xa&nbsp;</SPAN><SPAN style="COLOR: #000000">=</SPAN><SPAN style="COLOR: #000000">&nbsp;XMLAssert.CreateInstance();<BR></SPAN><SPAN style="COLOR: #008080">17</SPAN><SPAN style="COLOR: #000000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/ExpandedSubBlockEnd.gif" align=top>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;}</SPAN></SPAN><SPAN style="COLOR: #000000"><BR></SPAN><SPAN style="COLOR: #008080">18</SPAN><SPAN style="COLOR: #000000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/InBlock.gif" align=top><BR></SPAN><SPAN style="COLOR: #008080">19</SPAN><SPAN style="COLOR: #000000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/InBlock.gif" align=top>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;[Test]<BR></SPAN><SPAN style="COLOR: #008080">20</SPAN><SPAN style="COLOR: #000000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/InBlock.gif" align=top>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</SPAN><SPAN style="COLOR: #0000ff">public</SPAN><SPAN style="COLOR: #000000">&nbsp;</SPAN><SPAN style="COLOR: #0000ff">void</SPAN><SPAN style="COLOR: #000000">&nbsp;TestMethod()<BR></SPAN><SPAN style="COLOR: #008080">21</SPAN><SPAN style="COLOR: #000000"><IMG id=Codehighlighter1_362_2386_Open_Image onclick="this.style.display='none'; Codehighlighter1_362_2386_Open_Text.style.display='none'; Codehighlighter1_362_2386_Closed_Image.style.display='inline'; Codehighlighter1_362_2386_Closed_Text.style.display='inline';" src="http://www.blogjava.net/images/OutliningIndicators/ExpandedSubBlockStart.gif" align=top><IMG id=Codehighlighter1_362_2386_Closed_Image style="DISPLAY: none" onclick="this.style.display='none'; Codehighlighter1_362_2386_Closed_Text.style.display='none'; Codehighlighter1_362_2386_Open_Image.style.display='inline'; Codehighlighter1_362_2386_Open_Text.style.display='inline';" src="http://www.blogjava.net/images/OutliningIndicators/ContractedSubBlock.gif" align=top>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</SPAN><SPAN id=Codehighlighter1_362_2386_Closed_Text style="BORDER-RIGHT: #808080 1px solid; BORDER-TOP: #808080 1px solid; DISPLAY: none; BORDER-LEFT: #808080 1px solid; BORDER-BOTTOM: #808080 1px solid; BACKGROUND-COLOR: #ffffff"><IMG src="http://www.blogjava.net/images/dot.gif"></SPAN><SPAN id=Codehighlighter1_362_2386_Open_Text><SPAN style="COLOR: #000000">{<BR></SPAN><SPAN style="COLOR: #008080">22</SPAN><SPAN style="COLOR: #000000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/InBlock.gif" align=top>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</SPAN><SPAN style="COLOR: #008000">//</SPAN><SPAN style="COLOR: #008000">&nbsp;Init&nbsp;the&nbsp;xml&nbsp;input</SPAN><SPAN style="COLOR: #008000"><BR></SPAN><SPAN style="COLOR: #008080">23</SPAN><SPAN style="COLOR: #008000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/InBlock.gif" align=top></SPAN><SPAN style="COLOR: #000000">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</SPAN><SPAN style="COLOR: #0000ff">string</SPAN><SPAN style="COLOR: #000000">&nbsp;s1&nbsp;</SPAN><SPAN style="COLOR: #000000">=</SPAN><SPAN style="COLOR: #000000">&nbsp;</SPAN><SPAN style="COLOR: #000000">"</SPAN><SPAN style="COLOR: #000000"><IMG src="http://www.blogjava.net/images/dot.gif"></SPAN><SPAN style="COLOR: #000000">"</SPAN><SPAN style="COLOR: #000000">;<BR></SPAN><SPAN style="COLOR: #008080">24</SPAN><SPAN style="COLOR: #000000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/InBlock.gif" align=top>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</SPAN><SPAN style="COLOR: #0000ff">string</SPAN><SPAN style="COLOR: #000000">&nbsp;s2&nbsp;</SPAN><SPAN style="COLOR: #000000">=</SPAN><SPAN style="COLOR: #000000">&nbsp;</SPAN><SPAN style="COLOR: #000000">"</SPAN><SPAN style="COLOR: #000000"><IMG src="http://www.blogjava.net/images/dot.gif"></SPAN><SPAN style="COLOR: #000000">"</SPAN><SPAN style="COLOR: #000000">;<BR></SPAN><SPAN style="COLOR: #008080">25</SPAN><SPAN style="COLOR: #000000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/InBlock.gif" align=top><BR></SPAN><SPAN style="COLOR: #008080">26</SPAN><SPAN style="COLOR: #000000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/InBlock.gif" align=top>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</SPAN><SPAN style="COLOR: #008000">//</SPAN><SPAN style="COLOR: #008000">&nbsp;Init&nbsp;the&nbsp;options&nbsp;for&nbsp;your&nbsp;purpose</SPAN><SPAN style="COLOR: #008000"><BR></SPAN><SPAN style="COLOR: #008080">27</SPAN><SPAN style="COLOR: #008000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/InBlock.gif" align=top></SPAN><SPAN style="COLOR: #000000">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;xa.IsOrderSensitive&nbsp;</SPAN><SPAN style="COLOR: #000000">=</SPAN><SPAN style="COLOR: #000000">&nbsp;</SPAN><SPAN style="COLOR: #0000ff">false</SPAN><SPAN style="COLOR: #000000">;<BR></SPAN><SPAN style="COLOR: #008080">28</SPAN><SPAN style="COLOR: #000000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/InBlock.gif" align=top><BR></SPAN><SPAN style="COLOR: #008080">29</SPAN><SPAN style="COLOR: #000000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/InBlock.gif" align=top>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</SPAN><SPAN style="COLOR: #008000">//</SPAN><SPAN style="COLOR: #008000">&nbsp;Assert&nbsp;two&nbsp;XML&nbsp;inputs&nbsp;are&nbsp;equal</SPAN><SPAN style="COLOR: #008000"><BR></SPAN><SPAN style="COLOR: #008080">30</SPAN><SPAN style="COLOR: #008000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/InBlock.gif" align=top></SPAN><SPAN style="COLOR: #000000">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;xa.AreEqual(s1,&nbsp;s2,&nbsp;</SPAN><SPAN style="COLOR: #000000">"</SPAN><SPAN style="COLOR: #000000">Assertion&nbsp;Failed!</SPAN><SPAN style="COLOR: #000000">"</SPAN><SPAN style="COLOR: #000000">);<BR></SPAN><SPAN style="COLOR: #008080">31</SPAN><SPAN style="COLOR: #000000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/InBlock.gif" align=top><BR></SPAN><SPAN style="COLOR: #008080">32</SPAN><SPAN style="COLOR: #000000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/InBlock.gif" align=top>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</SPAN><SPAN style="COLOR: #008000">//</SPAN><SPAN style="COLOR: #008000">&nbsp;Compare&nbsp;two&nbsp;XML&nbsp;inputs&nbsp;and&nbsp;find&nbsp;all&nbsp;differences&nbsp;between&nbsp;them</SPAN><SPAN style="COLOR: #008000"><BR></SPAN><SPAN style="COLOR: #008080">33</SPAN><SPAN style="COLOR: #008000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/InBlock.gif" align=top></SPAN><SPAN style="COLOR: #000000">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;CompareResult&nbsp;r&nbsp;</SPAN><SPAN style="COLOR: #000000">=</SPAN><SPAN style="COLOR: #000000">&nbsp;xa.Compare(s1,&nbsp;s2);<BR></SPAN><SPAN style="COLOR: #008080">34</SPAN><SPAN style="COLOR: #000000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/InBlock.gif" align=top>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</SPAN><SPAN style="COLOR: #0000ff">foreach</SPAN><SPAN style="COLOR: #000000">&nbsp;(Diff&nbsp;d&nbsp;</SPAN><SPAN style="COLOR: #0000ff">in</SPAN><SPAN style="COLOR: #000000">&nbsp;r)<BR></SPAN><SPAN style="COLOR: #008080">35</SPAN><SPAN style="COLOR: #000000"><IMG id=Codehighlighter1_826_878_Open_Image onclick="this.style.display='none'; Codehighlighter1_826_878_Open_Text.style.display='none'; Codehighlighter1_826_878_Closed_Image.style.display='inline'; Codehighlighter1_826_878_Closed_Text.style.display='inline';" src="http://www.blogjava.net/images/OutliningIndicators/ExpandedSubBlockStart.gif" align=top><IMG id=Codehighlighter1_826_878_Closed_Image style="DISPLAY: none" onclick="this.style.display='none'; Codehighlighter1_826_878_Closed_Text.style.display='none'; Codehighlighter1_826_878_Open_Image.style.display='inline'; Codehighlighter1_826_878_Open_Text.style.display='inline';" src="http://www.blogjava.net/images/OutliningIndicators/ContractedSubBlock.gif" align=top>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</SPAN><SPAN id=Codehighlighter1_826_878_Closed_Text style="BORDER-RIGHT: #808080 1px solid; BORDER-TOP: #808080 1px solid; DISPLAY: none; BORDER-LEFT: #808080 1px solid; BORDER-BOTTOM: #808080 1px solid; BACKGROUND-COLOR: #ffffff"><IMG src="http://www.blogjava.net/images/dot.gif"></SPAN><SPAN id=Codehighlighter1_826_878_Open_Text><SPAN style="COLOR: #000000">{<BR></SPAN><SPAN style="COLOR: #008080">36</SPAN><SPAN style="COLOR: #000000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/InBlock.gif" align=top>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Console.WriteLine(d);<BR></SPAN><SPAN style="COLOR: #008080">37</SPAN><SPAN style="COLOR: #000000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/ExpandedSubBlockEnd.gif" align=top>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;}</SPAN></SPAN><SPAN style="COLOR: #000000"><BR></SPAN><SPAN style="COLOR: #008080">38</SPAN><SPAN style="COLOR: #000000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/InBlock.gif" align=top>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;CompareResult&nbsp;another&nbsp;</SPAN><SPAN style="COLOR: #000000">=</SPAN><SPAN style="COLOR: #000000">&nbsp;xa.Compare(s1,&nbsp;s2);<BR></SPAN><SPAN style="COLOR: #008080">39</SPAN><SPAN style="COLOR: #000000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/InBlock.gif" align=top>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;r.Add(another);<BR></SPAN><SPAN style="COLOR: #008080">40</SPAN><SPAN style="COLOR: #000000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/InBlock.gif" align=top>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</SPAN><SPAN style="COLOR: #0000ff">for</SPAN><SPAN style="COLOR: #000000">&nbsp;(</SPAN><SPAN style="COLOR: #0000ff">int</SPAN><SPAN style="COLOR: #000000">&nbsp;i&nbsp;</SPAN><SPAN style="COLOR: #000000">=</SPAN><SPAN style="COLOR: #000000">&nbsp;</SPAN><SPAN style="COLOR: #000000">0</SPAN><SPAN style="COLOR: #000000">;&nbsp;i&nbsp;</SPAN><SPAN style="COLOR: #000000">&lt;</SPAN><SPAN style="COLOR: #000000">&nbsp;r.Count;&nbsp;i</SPAN><SPAN style="COLOR: #000000">++</SPAN><SPAN style="COLOR: #000000">)<BR></SPAN><SPAN style="COLOR: #008080">41</SPAN><SPAN style="COLOR: #000000"><IMG id=Codehighlighter1_1022_1077_Open_Image onclick="this.style.display='none'; Codehighlighter1_1022_1077_Open_Text.style.display='none'; Codehighlighter1_1022_1077_Closed_Image.style.display='inline'; Codehighlighter1_1022_1077_Closed_Text.style.display='inline';" src="http://www.blogjava.net/images/OutliningIndicators/ExpandedSubBlockStart.gif" align=top><IMG id=Codehighlighter1_1022_1077_Closed_Image style="DISPLAY: none" onclick="this.style.display='none'; Codehighlighter1_1022_1077_Closed_Text.style.display='none'; Codehighlighter1_1022_1077_Open_Image.style.display='inline'; Codehighlighter1_1022_1077_Open_Text.style.display='inline';" src="http://www.blogjava.net/images/OutliningIndicators/ContractedSubBlock.gif" align=top>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</SPAN><SPAN id=Codehighlighter1_1022_1077_Closed_Text style="BORDER-RIGHT: #808080 1px solid; BORDER-TOP: #808080 1px solid; DISPLAY: none; BORDER-LEFT: #808080 1px solid; BORDER-BOTTOM: #808080 1px solid; BACKGROUND-COLOR: #ffffff"><IMG src="http://www.blogjava.net/images/dot.gif"></SPAN><SPAN id=Codehighlighter1_1022_1077_Open_Text><SPAN style="COLOR: #000000">{<BR></SPAN><SPAN style="COLOR: #008080">42</SPAN><SPAN style="COLOR: #000000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/InBlock.gif" align=top>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Console.WriteLine(r[i]);<BR></SPAN><SPAN style="COLOR: #008080">43</SPAN><SPAN style="COLOR: #000000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/ExpandedSubBlockEnd.gif" align=top>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;}</SPAN></SPAN><SPAN style="COLOR: #000000"><BR></SPAN><SPAN style="COLOR: #008080">44</SPAN><SPAN style="COLOR: #000000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/InBlock.gif" align=top>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</SPAN><SPAN style="COLOR: #0000ff">if</SPAN><SPAN style="COLOR: #000000">&nbsp;(r.AreEqual)<BR></SPAN><SPAN style="COLOR: #008080">45</SPAN><SPAN style="COLOR: #000000"><IMG id=Codehighlighter1_1119_1167_Open_Image onclick="this.style.display='none'; Codehighlighter1_1119_1167_Open_Text.style.display='none'; Codehighlighter1_1119_1167_Closed_Image.style.display='inline'; Codehighlighter1_1119_1167_Closed_Text.style.display='inline';" src="http://www.blogjava.net/images/OutliningIndicators/ExpandedSubBlockStart.gif" align=top><IMG id=Codehighlighter1_1119_1167_Closed_Image style="DISPLAY: none" onclick="this.style.display='none'; Codehighlighter1_1119_1167_Closed_Text.style.display='none'; Codehighlighter1_1119_1167_Open_Image.style.display='inline'; Codehighlighter1_1119_1167_Open_Text.style.display='inline';" src="http://www.blogjava.net/images/OutliningIndicators/ContractedSubBlock.gif" align=top>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</SPAN><SPAN id=Codehighlighter1_1119_1167_Closed_Text style="BORDER-RIGHT: #808080 1px solid; BORDER-TOP: #808080 1px solid; DISPLAY: none; BORDER-LEFT: #808080 1px solid; BORDER-BOTTOM: #808080 1px solid; BACKGROUND-COLOR: #ffffff"><IMG src="http://www.blogjava.net/images/dot.gif"></SPAN><SPAN id=Codehighlighter1_1119_1167_Open_Text><SPAN style="COLOR: #000000">{<BR></SPAN><SPAN style="COLOR: #008080">46</SPAN><SPAN style="COLOR: #000000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/InBlock.gif" align=top>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</SPAN><SPAN style="COLOR: #008000">//</SPAN><SPAN style="COLOR: #008000">&nbsp;They&nbsp;are&nbsp;equal</SPAN><SPAN style="COLOR: #008000"><BR></SPAN><SPAN style="COLOR: #008080">47</SPAN><SPAN style="COLOR: #008000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/ExpandedSubBlockEnd.gif" align=top></SPAN><SPAN style="COLOR: #000000">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;}</SPAN></SPAN><SPAN style="COLOR: #000000"><BR></SPAN><SPAN style="COLOR: #008080">48</SPAN><SPAN style="COLOR: #000000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/InBlock.gif" align=top><BR></SPAN><SPAN style="COLOR: #008080">49</SPAN><SPAN style="COLOR: #000000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/InBlock.gif" align=top>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</SPAN><SPAN style="COLOR: #008000">//</SPAN><SPAN style="COLOR: #008000">&nbsp;Assert&nbsp;two&nbsp;XML&nbsp;declaration&nbsp;of&nbsp;the&nbsp;two&nbsp;XML&nbsp;inputs&nbsp;are&nbsp;equal</SPAN><SPAN style="COLOR: #008000"><BR></SPAN><SPAN style="COLOR: #008080">50</SPAN><SPAN style="COLOR: #008000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/InBlock.gif" align=top></SPAN><SPAN style="COLOR: #000000">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;xa.AreDeclareEqual(s1,&nbsp;s2,&nbsp;</SPAN><SPAN style="COLOR: #000000">"</SPAN><SPAN style="COLOR: #000000">Declarations&nbsp;are&nbsp;not&nbsp;equal</SPAN><SPAN style="COLOR: #000000">"</SPAN><SPAN style="COLOR: #000000">);<BR></SPAN><SPAN style="COLOR: #008080">51</SPAN><SPAN style="COLOR: #000000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/InBlock.gif" align=top><BR></SPAN><SPAN style="COLOR: #008080">52</SPAN><SPAN style="COLOR: #000000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/InBlock.gif" align=top>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</SPAN><SPAN style="COLOR: #008000">//</SPAN><SPAN style="COLOR: #008000">&nbsp;Assert&nbsp;two&nbsp;document&nbsp;types&nbsp;of&nbsp;the&nbsp;two&nbsp;XML&nbsp;inputs&nbsp;are&nbsp;equal</SPAN><SPAN style="COLOR: #008000"><BR></SPAN><SPAN style="COLOR: #008080">53</SPAN><SPAN style="COLOR: #008000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/InBlock.gif" align=top></SPAN><SPAN style="COLOR: #000000">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;xa.AreDocTypeEqual(s1,&nbsp;s2,&nbsp;</SPAN><SPAN style="COLOR: #000000">"</SPAN><SPAN style="COLOR: #000000">DocTypes&nbsp;are&nbsp;not&nbsp;equal</SPAN><SPAN style="COLOR: #000000">"</SPAN><SPAN style="COLOR: #000000">);<BR></SPAN><SPAN style="COLOR: #008080">54</SPAN><SPAN style="COLOR: #000000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/InBlock.gif" align=top><BR></SPAN><SPAN style="COLOR: #008080">55</SPAN><SPAN style="COLOR: #000000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/InBlock.gif" align=top>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</SPAN><SPAN style="COLOR: #008000">//</SPAN><SPAN style="COLOR: #008000">&nbsp;Assert&nbsp;the&nbsp;validity&nbsp;of&nbsp;an&nbsp;XML&nbsp;input</SPAN><SPAN style="COLOR: #008000"><BR></SPAN><SPAN style="COLOR: #008080">56</SPAN><SPAN style="COLOR: #008000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/InBlock.gif" align=top></SPAN><SPAN style="COLOR: #000000">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;XMLAssert.IsValid(</SPAN><SPAN style="COLOR: #000000">"</SPAN><SPAN style="COLOR: #000000"><IMG src="http://www.blogjava.net/images/dot.gif"></SPAN><SPAN style="COLOR: #000000">"</SPAN><SPAN style="COLOR: #000000">);<BR></SPAN><SPAN style="COLOR: #008080">57</SPAN><SPAN style="COLOR: #000000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/InBlock.gif" align=top>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;XMLAssert.IsValidFile(</SPAN><SPAN style="COLOR: #000000">@"</SPAN><SPAN style="COLOR: #000000">C:\<IMG src="http://www.blogjava.net/images/dot.gif"></SPAN><SPAN style="COLOR: #000000">"</SPAN><SPAN style="COLOR: #000000">);<BR></SPAN><SPAN style="COLOR: #008080">58</SPAN><SPAN style="COLOR: #000000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/InBlock.gif" align=top><BR></SPAN><SPAN style="COLOR: #008080">59</SPAN><SPAN style="COLOR: #000000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/InBlock.gif" align=top>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</SPAN><SPAN style="COLOR: #008000">//</SPAN><SPAN style="COLOR: #008000">&nbsp;Assert&nbsp;the&nbsp;evaluation&nbsp;of&nbsp;an&nbsp;XPath&nbsp;expression&nbsp;on&nbsp;an&nbsp;XML&nbsp;input&nbsp;will&nbsp;<BR></SPAN><SPAN style="COLOR: #008080">60</SPAN><SPAN style="COLOR: #008000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/InBlock.gif" align=top>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</SPAN><SPAN style="COLOR: #008000">//</SPAN><SPAN style="COLOR: #008000">&nbsp;return&nbsp;the&nbsp;expected&nbsp;value</SPAN><SPAN style="COLOR: #008000"><BR></SPAN><SPAN style="COLOR: #008080">61</SPAN><SPAN style="COLOR: #008000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/InBlock.gif" align=top></SPAN><SPAN style="COLOR: #000000">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;xa.AreXpathEqual(</SPAN><SPAN style="COLOR: #000000">"</SPAN><SPAN style="COLOR: #000000">&lt;a/&gt;</SPAN><SPAN style="COLOR: #000000">"</SPAN><SPAN style="COLOR: #000000">,&nbsp;</SPAN><SPAN style="COLOR: #000000">"</SPAN><SPAN style="COLOR: #000000">/r/a[2]</SPAN><SPAN style="COLOR: #000000">"</SPAN><SPAN style="COLOR: #000000">,&nbsp;s1,&nbsp;<BR></SPAN><SPAN style="COLOR: #008080">62</SPAN><SPAN style="COLOR: #000000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/InBlock.gif" align=top>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</SPAN><SPAN style="COLOR: #000000">"</SPAN><SPAN style="COLOR: #000000">The&nbsp;xpath&nbsp;expression&nbsp;doesn't&nbsp;return&nbsp;&lt;a/&gt;</SPAN><SPAN style="COLOR: #000000">"</SPAN><SPAN style="COLOR: #000000">);<BR></SPAN><SPAN style="COLOR: #008080">63</SPAN><SPAN style="COLOR: #000000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/InBlock.gif" align=top><BR></SPAN><SPAN style="COLOR: #008080">64</SPAN><SPAN style="COLOR: #000000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/InBlock.gif" align=top>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</SPAN><SPAN style="COLOR: #008000">//</SPAN><SPAN style="COLOR: #008000">&nbsp;Assert&nbsp;an&nbsp;XPath&nbsp;expression&nbsp;is&nbsp;exist&nbsp;for&nbsp;an&nbsp;XML&nbsp;input</SPAN><SPAN style="COLOR: #008000"><BR></SPAN><SPAN style="COLOR: #008080">65</SPAN><SPAN style="COLOR: #008000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/InBlock.gif" align=top></SPAN><SPAN style="COLOR: #000000">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;XMLAssert.XpathExist(</SPAN><SPAN style="COLOR: #000000">"</SPAN><SPAN style="COLOR: #000000">//@b='c'</SPAN><SPAN style="COLOR: #000000">"</SPAN><SPAN style="COLOR: #000000">,&nbsp;s1,&nbsp;<BR></SPAN><SPAN style="COLOR: #008080">66</SPAN><SPAN style="COLOR: #000000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/InBlock.gif" align=top>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</SPAN><SPAN style="COLOR: #000000">"</SPAN><SPAN style="COLOR: #000000">The&nbsp;xml&nbsp;document&nbsp;doesn't&nbsp;have&nbsp;the&nbsp;xpath&nbsp;expression</SPAN><SPAN style="COLOR: #000000">"</SPAN><SPAN style="COLOR: #000000">);<BR></SPAN><SPAN style="COLOR: #008080">67</SPAN><SPAN style="COLOR: #000000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/InBlock.gif" align=top><BR></SPAN><SPAN style="COLOR: #008080">68</SPAN><SPAN style="COLOR: #000000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/InBlock.gif" align=top>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</SPAN><SPAN style="COLOR: #008000">//</SPAN><SPAN style="COLOR: #008000">&nbsp;Assert&nbsp;an&nbsp;XML&nbsp;input&nbsp;is&nbsp;included&nbsp;by&nbsp;another&nbsp;one</SPAN><SPAN style="COLOR: #008000"><BR></SPAN><SPAN style="COLOR: #008080">69</SPAN><SPAN style="COLOR: #008000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/InBlock.gif" align=top></SPAN><SPAN style="COLOR: #000000">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;xa.IsIncluded(s1,&nbsp;s2,&nbsp;</SPAN><SPAN style="COLOR: #000000">"</SPAN><SPAN style="COLOR: #000000">The&nbsp;{0}&nbsp;is&nbsp;not&nbsp;included&nbsp;in&nbsp;{1}</SPAN><SPAN style="COLOR: #000000">"</SPAN><SPAN style="COLOR: #000000">,&nbsp;s1,&nbsp;s2);<BR></SPAN><SPAN style="COLOR: #008080">70</SPAN><SPAN style="COLOR: #000000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/InBlock.gif" align=top><BR></SPAN><SPAN style="COLOR: #008080">71</SPAN><SPAN style="COLOR: #000000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/InBlock.gif" align=top>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</SPAN><SPAN style="COLOR: #008000">//</SPAN><SPAN style="COLOR: #008000">&nbsp;The&nbsp;Counter</SPAN><SPAN style="COLOR: #008000"><BR></SPAN><SPAN style="COLOR: #008080">72</SPAN><SPAN style="COLOR: #008000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/InBlock.gif" align=top></SPAN><SPAN style="COLOR: #000000">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Assert.AreEqual(</SPAN><SPAN style="COLOR: #000000">6</SPAN><SPAN style="COLOR: #000000">,&nbsp;xa.Counter);<BR></SPAN><SPAN style="COLOR: #008080">73</SPAN><SPAN style="COLOR: #000000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/InBlock.gif" align=top><BR></SPAN><SPAN style="COLOR: #008080">74</SPAN><SPAN style="COLOR: #000000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/InBlock.gif" align=top>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</SPAN><SPAN style="COLOR: #008000">//</SPAN><SPAN style="COLOR: #008000">&nbsp;XMLInput&nbsp;can&nbsp;use&nbsp;in&nbsp;all&nbsp;the&nbsp;samples&nbsp;above</SPAN><SPAN style="COLOR: #008000"><BR></SPAN><SPAN style="COLOR: #008080">75</SPAN><SPAN style="COLOR: #008000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/InBlock.gif" align=top></SPAN><SPAN style="COLOR: #000000">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;xa.AreEqual(XMLInput.CreateFromString(s1),&nbsp;<BR></SPAN><SPAN style="COLOR: #008080">76</SPAN><SPAN style="COLOR: #000000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/InBlock.gif" align=top>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;XMLInput.CreateFromString(s2),&nbsp;</SPAN><SPAN style="COLOR: #000000">"</SPAN><SPAN style="COLOR: #000000">Assertion&nbsp;Failed!</SPAN><SPAN style="COLOR: #000000">"</SPAN><SPAN style="COLOR: #000000">);<BR></SPAN><SPAN style="COLOR: #008080">77</SPAN><SPAN style="COLOR: #000000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/ExpandedSubBlockEnd.gif" align=top>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;}</SPAN></SPAN><SPAN style="COLOR: #000000"><BR></SPAN><SPAN style="COLOR: #008080">78</SPAN><SPAN style="COLOR: #000000"><IMG src="http://www.blogjava.net/images/OutliningIndicators/ExpandedBlockEnd.gif" align=top>&nbsp;&nbsp;&nbsp;&nbsp;}</SPAN></SPAN></DIV></DIV></FONT></FONT></FONT><img src ="http://www.blogjava.net/briansun/aggbug/7765.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/briansun/" target="_blank">Brian Sun</a> 2005-07-15 13:22 <a href="http://www.blogjava.net/briansun/archive/2005/07/15/7765.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>大公司的困惑</title><link>http://www.blogjava.net/briansun/archive/2005/04/21/3564.html</link><dc:creator>Brian Sun</dc:creator><author>Brian Sun</author><pubDate>Thu, 21 Apr 2005 02:23:00 GMT</pubDate><guid>http://www.blogjava.net/briansun/archive/2005/04/21/3564.html</guid><wfw:comment>http://www.blogjava.net/briansun/comments/3564.html</wfw:comment><comments>http://www.blogjava.net/briansun/archive/2005/04/21/3564.html#Feedback</comments><slash:comments>9</slash:comments><wfw:commentRss>http://www.blogjava.net/briansun/comments/commentRss/3564.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/briansun/services/trackbacks/3564.html</trackback:ping><description><![CDATA[<p>在写完了前面那篇“4月16日评点IBM”之后的某个早晨，我和领导共进早餐，由于我们吃饭的地方其实是方正的餐厅，所以席间略谈了几句方正。这是
我猛然发现，方正原来也是一个技术型很专一的企业，这几年逐渐变得平庸了，即使没有像经不起风霜的小企业一样完蛋，也不能否认这么多年屹立不倒多少也有吃
老本的嫌疑，但是，究竟是什么使这样一个显赫一时直至今日仍然在自己的领域是龙头老大的企业失去当年励精图治的成就呢？<br><br>我想答案可能与那
篇文章中提到的IBM面临的情况类似，当PC革命到来的时候，作为一个以计算机技术（整体中的大部分）为主要研究对象的龙头老大，岂能眼睁睁看到这样一块
风水宝地被后生抢走，岂能眼睁睁看着交手多年的竞争对手大把大把捞银子，岂能眼睁睁看着国内外企盼PC技术给人类带来巨大变革的一双双渴望的眼睛，即使这
种变革像雾像雨又像风，来得快也去得快！<br><br>其实仔细想想这样一个大公司的困惑吧。一个像IBM、方正、HP、Intel这样的企业，在PC
诞生之前，他们就已经名声显赫，有万贯家产，可是他们越是德高望重，面临的困惑也就越大。究竟是顺应时代变革、勇攀新的高峰，还是任凭风吹雨打、我自岿然
不动！究竟是抢占先机、舍我其谁，还是浅尝辄止、随风应变！在尝到甜头的时候，究竟是见好就收、预防否极泰来，还是孤注一掷、争取利润最大化。在遇到困难
和暂时性的挫败时，究竟是浪子回头金不换，还是去留肝胆两昆仑！（不好意思，话说大了<img src="http://www.blogjava.net/Emoticons/QQ/14.gif" border="0" height="20" width="20">）。很小的时候度过一本留美博士写的书，书的大概内容是讲IT发展史的，但是由于作者是DBA出身（是MBA的升级版，不是数据库管理员<img src="http://www.blogjava.net/Emoticons/QQ/13.gif" border="0" height="20" width="20">），所以商业思考多于技术见解。这本书中很多部分就是以这样的两难选题开始的，这在管理学中是非常可怕的战略选择，它足可以决定一个企业的生死，例子嘛，IT界有的是。<br></p>
  <p>想想刚刚提到的IBM，在这样的PC大潮中不能见好就收，致使偏离了自己的轨道；方正，没有将有限的资源投入到原来那分很有前途的职业中去，当
诸多外敌进入市场时不能很好的守住阵地；HP，任凭PC部门摊薄优质资产的利润率。反过来说，IBM，成长和发展的途中没有丢弃自己计算机技术霸主的地
位；方正，依然是闪亮的明星；HP，尽管付出了沉重的代价，总算还戴上了自己梦寐以求的王冠；苹果，在尝试了诸多路线之后才发现岿然不动才是属于自己的致
胜之道。<br><br>这些毕竟都是有得有失之人。有完全失败的吗？有！王安，在不能应对突如其来的开放架构的战争中全军覆没；Novell，在不能应对突如其来的互联网大潮中几乎夭折；宏基，风采不见已经多年。<br><br>有完全成功的吗？当然也有！Intel，由于把握了合适的时机，已经时常拿Mr.Incredible（超人<img src="http://www.blogjava.net/Emoticons/QQ/17.gif" border="0" height="20" width="20">）和自己比较了；Microsoft，得益于IBM的培养成为人类历史的篇章。<br><br>有浅尝辄止的成功者吗？有～。想想GE吧，当PC的时代即将到来时，华尔街无一例外的认为GE将寻觅时机和IBM正面交锋，结果是人家玩的很潇洒，不知道是不是某个尚未公布的战略矩阵计算的结果。<br><br>退
一步讲，这也许就是一个大企业应该承担的责任，越大的企业应该面临越难的抉择、应对越大的风险、抵御越大的诱惑、同时享受越多的利润。但也应该注意的是，
战略选择在这样的环境下对大企业有更多的意义，所以大企业更应该重视战略问题，从自身的特点和行业的特性出发，把握任何对时代脉搏的真实未来的预言。但愿
这些对国内的企业是个借鉴。<br><br>提供有限咨询的泡泡<br><br></p>
<img src ="http://www.blogjava.net/briansun/aggbug/3564.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/briansun/" target="_blank">Brian Sun</a> 2005-04-21 10:23 <a href="http://www.blogjava.net/briansun/archive/2005/04/21/3564.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>4月16日评点IBM</title><link>http://www.blogjava.net/briansun/archive/2005/04/16/3336.html</link><dc:creator>Brian Sun</dc:creator><author>Brian Sun</author><pubDate>Sat, 16 Apr 2005 00:09:00 GMT</pubDate><guid>http://www.blogjava.net/briansun/archive/2005/04/16/3336.html</guid><wfw:comment>http://www.blogjava.net/briansun/comments/3336.html</wfw:comment><comments>http://www.blogjava.net/briansun/archive/2005/04/16/3336.html#Feedback</comments><slash:comments>22</slash:comments><wfw:commentRss>http://www.blogjava.net/briansun/comments/commentRss/3336.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/briansun/services/trackbacks/3336.html</trackback:ping><description><![CDATA[有人问为什么总是以“评点”命名我的Blog文章，我说那是我取错了名字，应该叫“小议”；有人问为什么总是“几月几日评点什么”呢，我说那是因为虽然我
的想法总是来源于平时的思考，但我的写作欲望却来源于一时的冲动，所以我要记住我这次冲动的日期；但是，还有更重要的一点，那就是我一时的冲动并不表示我
对一个事物的完全认识，所以我以后还会再“小议”这个事物，那时我又要写“几月几日再评点什么”了。^_^<br>
<br>
事情要从扬州说起，昨日在博客园领导dudu的解说下游览了扬州著名的两个景点，瘦西湖和大明寺，还品尝了暴多扬州美味小吃，（全劳dudu破费，再次感
谢），既非常疲惫，又欣喜万分。席间我们谈到IBM，我又大发神经，把我对IBM的很多认识统统说了一遍，情绪十分激动，虽严重影响了周围客人的食欲，但
滋生了评点IBM的欲望，于是赶回南京，写了这篇，正在进膳的朋友免看。^_^<br>
<br>
<font style="color: rgb(255, 0, 0); font-weight: bold;" size="4">1。IBM的开始。</font><br>
IBM的年龄比目前世界上大多数人要大，它的早期辉煌出自两代Thomas Watson夫子之手。老Thomas
Watson缔造了IBM，并使得IBM的基调始终停留在商用机器的领域，当时是没有电子计算机的，所以IBM的主要产品是打孔机和计时器，但此时的
IBM已经是名利双收，它的名来自它为当时全国性的一次人口普查提供了全部设备，它的利则来自二战时不得不生产的军火工业。小Thomas
Watson和他爸爸有同样的名字，只是中间名字不同，崇拜技术要多于崇拜老爸，他经常为了一点点小的技术方面的问题同老爸争的不可开交。比如曾经有一个
年轻人拿着一个旅行箱大小的设备来见他们父子，这台机器只会做基本的加法和减法，显然他的目的是找IBM要投资，这个人演示了这台机器，老Watson发
现这台机器算的还不如一个熟练使用中国算盘的小姑娘，立即觉得这个东西没有，而小Watson却觉得既然它可以算加法以后一定可以算乘法，于是很想投资。
父子两为了这件事整整吵了一夜，第二天人们发现他们在房间抱头痛哭。这个例子只是为了说明父子两对技术的重视程度，事实上，当小Watson接手IBM时
他也没有再投资那个年轻人，但是这个时候他对整个计算机工业的投资已经启动了。<br>
<br>
小Watson和他老爸一样重视技术，记得他曾单独嘱咐过两位科学家：“一定要把System/360搞好！”这两个人当中资历比较小的那个叫做Fred
Brooks，他深信自己的体系结构是正确的，而老前辈却认为他自己的体系结构是正确的，于是那段日子，Watson总裁几乎天天和他们泡在一起，他好像
一个辩论赛的教练，倾听总是多于发表意见，他让Brooks说他的体系结构有哪些优点，然后让前辈说这个结构哪里不对头，又让前辈说自己的体系结构，再让
Brooks说哪里不对头。就这样反复来回几十遍，问题总会走到两个人都满意的位置上去。最后只剩一个问题解决不了的时候，三个人同时发现这就是真正的争
议所在，这时Watson就拍板说让前辈全权负责，有最终决定权，然后前辈也没有辜负老总的一片期望，选择并培养了Brooks，并最终让Brooks担
当了System/360的主设计师。<br>
<br>
那是一个怎样的年代，老总可以和两代技术专家坐在一起谈论一个系统的实现细节。而且这还是IBM的老总，这是一个现在想都不要想的场景，而这一切印证了
Time对IBM的一句评语：“IBM生于崇尚技术的年代！”事实上，Brooks在System/360成功很多年以后才入选IBM
Fellow（名士），说明IBM的科研人才之多，可谓富可敌国。<br>
<font style="color: rgb(0, 128, 0); font-weight: bold;" size="4"><br>
2。IBM的衰落。</font><br>
这样神话般的日子持续了几十年，历经了两代老总的时间。但是对于生来就是贵族的小Watson而言，工作并不是他的全部，所以他很早就辞掉了在IBM的全
部职务，回家过安闲的晚年。在他执政IBM的最后一段日子了，个人电脑业兴起了，Steve
Jobs的一夜暴富让很多人红了眼，HP和IBM都在其中，这两大电子工业的巨头在口水快要淹死自己的同时都冲向了这个广阔的天地。IBM的PC——个人
电脑——其创意也是直接出自小Watson之手，但他万万没有想到的是，这个发明改变了整个世界的面貌！<br>
<br>
在此之后的几十年，IBM同HP同一些兴起的小公司一起争夺PC业的霸主地位。像所以其它的事物一样，这既是IBM鼎盛时期的开始，也是必将衰落的标志，
原因很简单——它背离了自己的灵魂。在与这些公司竞争的过程中，IBM渐渐力不从心，这段时间的历史被载入了很多大学MBA的案例教材中，简单数数就会知
道，作为PC发明者的IBM很少能在这个领域呼风唤雨，成本是Dell的，新技术是Compaq的，家用电脑是HP的，时尚是Apple的，同时它还免不
了要看看Sony和Fujistu的脸色。为什么当年能在技术界称王称霸的IBM会和这些以制造业为基础的企业处在同样的竞争集团呢？这个问题的本身就是
答案。一个企业当他在自己的发明上挣够了钱之后，他就面临做精做细的问题，有些公司能处理的好，比如Adobe，有些不能，比如Apple，这不是能力问
题，这就是生活，他总是多姿多彩的，玩的起的人上天堂，输的起的人走四方！<br>
<br>
不是谁发明了什么就一定能把它做好的！可惜绝大部分技术出身的人不能想通这个问题，即使想通了，轮到自己了也不会去做，这需要多大的勇气啊，让技术人员去
选择技术根本就不是一个稳重的大公司会做出的决定，可惜直到90年代IBM才意识到这一点，此时的IBM已是内忧外患，四面楚歌，这个时期的最后一位
CEO曾计划将IBM拆成13个子公司，彼此业务比较独立，（幸好没有让他得逞，否则人类将失去真正宝贵的财富），自身的危机和整个行业的不景气已经让他
成为一头“瘦死的骆驼”，而接下来的三个字也特别需要一位具有独特思维方式的CEO才能续写。<br>
<br>
<font style="color: rgb(128, 0, 128); font-weight: bold;" size="4">3。IBM的复苏。</font><br>
IBM求贤若渴，董事会雇佣的猎头公司几乎跑遍了每一家IT企业，去挖他们的CEO，其中最富有戏剧性的，就是猎头公司居然找过GE的Jack，
Apple的Jobs和Microsoft的Bill
Gates！韦尔奇认为IBM需要认真考虑自己的业务，不该做的就不要做，至于IBM究竟哪些是不该做的，韦尔奇认为IBM在很多领域已经不占优势，最好
的办法就是IBM开拓新的领域，不仅可以卖电脑，还可以卖其它电器。Jobs认为IBM应该和Apple合并成一个公司，专心致志研究如何生产个人电脑。
Gates则认为IBM应该老老实实生产大型机，不要干预低端业务和个人领域。董事会在一次又一次的会议中几乎失去了他们所有的耐心和信心，这些疯狂的人
是不能引入IBM的，可如果没有一个能力和洞察力的双料冠军，IBM就不得不面对拆分的境地。还好，猎头公司没有让人们失望，他们为IBM找到了一个再一
次被收入主流MBA案例教材的借口——一个不懂技术的人可以入主计算机技术的发源地吗？——而他，就是Louis Gestner。<br>
<br>
Gestner坚决反对拆分IBM，他认为IBM最重要的一件事就是调整姿态，把自己摆在一个正确的位置上。他问每一个员工：“IBM是一个怎样的企
业？”员工回答：“IBM是一个科技企业。”STOP！不要再说“IBM是一个科技企业了！”IBM哪里有一个科技企业的样子。Gestner说：
“IBM是一个服务型企业！”他率先带领管理层代表团访问了很多大客户，比如P&amp;G，此举令P&amp;G受宠若惊。他广泛采纳客户的意见，他经
常动辄邀请200个大客户参加一个会议，为的就是想要知道客户需要什么。技术圈里的人们总是固执的认为，卖一件具有高科技含量的商品才是挣钱的道理，
Gestner却要告诉人们“挣钱没有道理”，要想发展科技，就要养活一批高科技人才，要想养活这些全球顶尖的人才就要钱，大量的钱，而这些钱只能靠卖服
务来挣。在Gestner执政的时间里，IBM发生了历史上最大规模的变革，且是两代Watson父子想都不会想到的。<br>
<br>
IBM从此变成了一家以客户为核心的价值整合型企业。在硬件方面，Gestner坚信不能要的就是不要。他首先卖出了IBM的大型机部门，可是IBM发明
了大型机！Gestner说“不是谁发明了什么就一定能把它做好的！”不久，他又卖出了IBM硬盘事业部，可是IBM发明了硬盘！Gestner又说“不
是谁发明了什么就一定能把它做好的！”如今，IBM又卖了他的PC部门，可是IBM发明了PC，Gestner虽然已经卸任，他也丝毫不回避这笔他一手创
造的买卖，“不是谁发明了什么就一定能把它做好的！”<br>
<br>
在软件方面，当Gestner把玩IBM的数据库时，人们的惯性思维认为Gestner也要把数据库部门给卖了，因为是IBM发明了数据库，可是大人物做
事往往出人意料，Gestner不但没有卖掉数据库部门，反而大规模追加投资，让IBM派出史上最强大的研发力量把数据库包装成他的第一个软件品牌
DB2。此后Gestner悉心听取客户的意见，客户说需要具有协作能力的Office，IBM就强行收购Lotus；客户说需要加强网络管理，IBM就
买下了Tivoli；客户说需要中间件，IBM又包装了所有此类的产品为Websphere；即使在Gestner临卸任之前，他还谈妥了IBM收购
Rational的事宜，至此，IBM已经从一家做硬件的厂商，转变为拥有五大软件品牌的新蓝色巨人。<br>
<br>
Gestner终于可以说一句“瘦死的骆驼比马大”了，虽然IBM已经不再是从前的IBM可是Gestner让他重新找回了自信，好比一个失去光芒的普通
石头，在Gestner的手上变成了另一种形式的艺术品，再次散发出了迷人的魅力。这些岂能是韦尔奇、Jobs和Gates能想到的！这就是一个非技术人
员成为IBM的CEO之后的事。此后，很多大公司纷纷效仿，HP请来了漂亮了女总裁，微软换了富有亲和力的鲍尔曼，都企图显示出自己重视客户的一面，改善
其与大客户之间的关系。然而Gestner绝没有他们想象的那么简单，在让IBM转型为一个服务企业的同时，Gestner又重新重视起IBM的科研力
量，失去的军方订单又回来了！IBM在恢复了商业巨头的形象之后又恢复了他的科技巨人形象，很多在抢夺PC业霸主地位时停滞的项目又重新焕发出了生机，这
些都是其他CEO没有想到的，他们面对的又是一个双料型的IBM，他们不得不再次朝圣以维持对计算机前沿技术的追随，Gestner没有让IBM偏离了轨
道，而是让他重新回到了大小Thomas父子领导IBM的那个年代，让他重新拥有了崇尚科技的氛围，让他重新回归了自我，百年IBM，百年回归！<br>
<br>
<font style="color: rgb(255, 165, 0); font-weight: bold;" size="4">4。IBM的神话。</font><br>
Gestner几乎让IBM上演了一出“The Return Of The
King”，这在其它公司眼里仿佛是一种潜移默化的变革，而在Gestner眼里却是一种长期战略部署和细节性技术态度的有效结合。在硬件的领域，
Gestner要说的只有一句话，做不好就不做，没什么大不了，他认为官僚并不是IBM的致命弱点，相反，官僚有官僚的好处，那就是稳定，可信赖。想想
吧，一个像微软一样的公司，对于以往的技术说不干就不干了，大客户怎么放心的下；一个像HP一样的企业，总是因为分脏不均就赶走自己的总裁，大客户怎么放
心的下。Gestner认为IBM最大的问题不是他的官僚，而是他不能轻便的革新。在他入主IBM时，Sun主席Scott
McNearly曾讥笑IBM要变成International Biscuit
Maker（因为Gestner以前是雷诺的接班人候选，后者拥有全美最大的饼干生产企业Nabisco），Gestner没有让IBM去生产饼干，但他
却把IBM变得像一个饼干生产商一样灵活。没有什么是IBM一定要做的！没有什么是IBM一定能做的好的！没有什么是IBM能做好却又不做的！概括成一句
话就是“谁说大象不能跳舞”！<br>
<br>
在软件的世界，Gestner仍然笃信这句由他自己创造的名言。他从不回答“哪些技术是IBM要做的，哪些是IBM不要做的”这样的问题，他总是会说“我
不是个搞技术的，这个问题我不懂”，可他却有独特的眼光和思维方式。对于任何一个软件技术，他总是带着IBM分四步缓慢进入：<br>
1。观望。这时的IBM会说“我不做，但不排除我以后不做”。<br>
2。研究。你会在IBM的alphaworks上看到很多关于该技术的文章，此时的IBM在向人们传达的讯息是“我不做，但是如果我的客户做，我奉陪！”<br>
3。浅尝辄止。你会发现alphaworks上出现了该技术的专栏，IBM将相当一部分应用迁移到了该技术，可是这又怎么样，IBM在说“我做，不过随便做做。”<br>
4。全力出击。到了这个阶段，你会发现IBM给其它该领域的竞争对手以窒息的打击，IBM像是在说“现在轮到我了，你们都不要做了！”正如Gestner在自
己的书里写的一样，“问题不在于大象能不能跳舞，而在于一旦大象开始跳舞，蚂蚁必须离开舞台！”一旦IBM开始动手，其他人才反应过来已经为时已晚。<br>
<br>
如果你不信，可以看看Java的例子，当1995年Java诞生在Sun手里的时候，IBM持的态度是观望；1997年www蓬勃兴起，大量Java小应
用程序被应用在Web领域，IBM也做了很多，还做了JDK，此时是研究；到了1999年，Java企业版开始红红火火，大规模大利润的应用服务器浮出水
面，IBM终于看到了切入的时机，Websphere的出台让IBM“随便玩玩”；直到人们看到了以Eclipse命名的产品在2001年出台时，人们才
真正意识到IBM的野心，“一旦大象开始跳舞，蚂蚁必须离开舞台！”再看看Linux的例子吧，当IBM对Linux的支持如日中天成为Linux社团一
道亮丽风景的时候，当Linux的崇拜者们仰视IBM，等待IBM抛出一个主流Linux产品的时候，IBM却浅尝辄止，只要他的大部分产品都可以平滑过
渡到Linux就可以了，“我随便做做，你们玩吧”。<br>
<br>
有时我们也在想，如果Gestner不是Gestner呢，如果他是一个懂技术的Gestner他还能不能做到今天的这种战略思维呢，我们不得而知，历史也不允许假设，但有一点可以肯定，只有创造奇迹的人和见过奇迹的人，才会相信奇迹的存在。<br>
<br>
谁说泡泡不能跳舞<br>
<br>
<img src ="http://www.blogjava.net/briansun/aggbug/3336.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/briansun/" target="_blank">Brian Sun</a> 2005-04-16 08:09 <a href="http://www.blogjava.net/briansun/archive/2005/04/16/3336.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>高级重构方法的连用</title><link>http://www.blogjava.net/briansun/archive/2005/04/13/3205.html</link><dc:creator>Brian Sun</dc:creator><author>Brian Sun</author><pubDate>Wed, 13 Apr 2005 02:54:00 GMT</pubDate><guid>http://www.blogjava.net/briansun/archive/2005/04/13/3205.html</guid><wfw:comment>http://www.blogjava.net/briansun/comments/3205.html</wfw:comment><comments>http://www.blogjava.net/briansun/archive/2005/04/13/3205.html#Feedback</comments><slash:comments>3</slash:comments><wfw:commentRss>http://www.blogjava.net/briansun/comments/commentRss/3205.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/briansun/services/trackbacks/3205.html</trackback:ping><description><![CDATA[又是很久没有写Blog了，这两天大量的时间贡献给了两件事，一是看Eclipse的源代码（工作需要），二是不断回复以前写的文章的评论。今天请了假，
抽了点时间来讨论讨论重构。下面写的东西您可能不太赞同，可能没有遇到，也可能有其它更好的办法，而我的观点来自于我对Eclipse源代码的理解和感
悟，无论您有什么想法请评论告诉我，不甚感谢。<br>
<br>
1。如果让您随手写一个类，多半人会写出一个以名词命名的类，是的，我们的软件中大量的类是以名词来命名的。一个名词表明了一组对象的共同类型，那么这个类型一定包括该组对象的共同属性和共同方法。<br>
<br>
2。在几次迭代之后我们发现类的属性和方法都增多起来，这种粗放型的发展不利于软件系统的整体结构。而事实上，有很多类在80％的时间只需用到20％的属性代码，而20％的时间却需要用到80％的方法代码，因此，将访问率不同的属性和方法分开是必然的趋势。于是有了<font style="font-family: courier new; color: rgb(255, 0, 0); font-weight: bold;" size="3">Descriptor模式</font>，它将一个原始类分成属性集中化和方法集中化的两个类，属性类的命名方式采用原类名+Descriptor的方式，方法类可能沿用原名称，或重新取个名字以动词命名。这种重构还有一个好处就是属性类随时可以加载，而方法类可能要到需要用时才懒加载。<br>
<br>
3。在经过多次迭代的增加该类的代码之后，我们发现Descriptor类的属性增多起来，过多的属性使代码变得重量化，同时使结构变得不清晰，一个拥有
过多属性的类也会因知识过多而不易维护，此时最好的方法是将这个类分裂为两个，或多个。分裂的方法也有横向和纵向两种。横向的分裂使类变成两个不同的类，
它们往往叫两个不同的名字且都为名词，同时也可能互相持有对方<font style="font-weight: bold; font-family: courier new; color: rgb(255, 165, 0);" size="3">（Change Unidirectional Association to Bidirectional</font><font style="font-weight: bold; font-family: courier new; color: rgb(255, 165, 0);" size="3">）</font>。<br>
<br>
4。纵向的分裂方法<font style="font-weight: bold; color: rgb(165, 42, 42);" size="3"><span style="font-family: courier new;">（Extract Class）</span></font>往
往会将比较公共的部分分离取名为原类名+Model，另一个类名称不变，Model类是后者的父类。加过Model以后的类轻磅了很多，更便于管理，责任
也更轻。至于哪些属性应该放在父类界限不是很严格，通俗的办法是和原类名紧密相关的（特有的）属性应该留在原处，不是紧密相关的（特有的）放在Model
类，比如ID、Label什么的就应该放在Model类。<br>
<br>
5。上面的方法反复用几次，属性集中的类就会变得越来越多。这时软件结构虽然看的很清晰，可是使用起来大为不便，因为很多相关的属性可能会在同一个场合下使用，而它们的实体却可能分布在不同的对象中。解决这个问题的方法只有增加接口的数量<font style="font-family: courier new; font-weight: bold; color: rgb(0, 128, 0);" size="3">（Extract Interface）</font>，多使用一些小接口，每个小接口表达了一个方面的含义，使用者在使用这些小接口时无法触及它的实体对象<font style="font-family: courier new; font-weight: bold; color: rgb(238, 130, 238);" size="3">（Prototype）</font>，
这种方法的优劣性在于使用者对于架构的理解，如果用的好这种方法会显现出很多面向方面的特性，如果用的不好则是画蛇添足，导致了接口的泛滥（还记得Dll
Hell吗，Java是不是正在形成一个Interface Hell？Eclipse是不是正在形成一个Plugin Hell？）。<br>
<br>
6。在大量应用了方面接口之后，我们又面临着这样的问题，很多使用这些Model的人其实只是关心其中的一部分固定属性，和几个为数不多的固定方法，有时连重量级方法都不关心，只关心用以交互的查找型get方法，对于这些使用者，我们只需提供一个门面<font style="font-weight: bold; color: rgb(128, 0, 128);" size="3"><span style="font-family: courier new;">（Facade）</span></font>即
可。一个Facade包括在一个Model类和Descriptor类的群体中提供一组可以找到任何一个属性的线索，其中的每一个线索都开始于
Facade，结束于存放对应属性的属性类，且遵循“最常用到的属性，其线索最短”的原则。因而Facade绝不仅仅是一个类，而是一个完整的体系结构。<br>
<br>
7。接下来还有一个持久化的问题。如果一个类型存在对一个复杂类型的引用，这个复杂类型很可能被深深的隐藏在Facade之后，而且很可能是个不可持久化
的类型，那么如果前者要持久化，它只能保存一个该复杂类型的关键码，并在持久化唤醒时很容易通过某个服务取到该关键码所对应的对象。这个复杂过程没理由要
求Facade以外的类来完成，因此有了<font style="font-weight: bold; color: rgb(0, 0, 255);" size="3"><span style="font-family: courier new;">Reference模式（Change Value To Reference）</span></font>，即为那个复杂类型定义一个类，类名为原类名+Reference，其责任是保存原类型的关键码和查找原类型的真实对象。Reference类通常定义为可持久化。该模式的另一个好处是不必要常常访问Facade，因为一个Facade也有可能极其复杂。<br>
<br>
8。在分析完属性集中化的类和类群之间的关系之后，我们来看看方法集中化的类。这个类也有可能面临方法激增的问题，此时想把一个类拆分成多个可没有拆分属
性集中化的类那么容易了，因为它们往往相互调用，耦合度极高，但又不能不拆（还记得Kent
Beck曾经说过的吗，“如果一个类的责任超过三个，我们就必须把它拆开以保证每个类的责任都不超过三个”）！幸好我们有<font style="font-family: courier new; font-weight: bold; color: rgb(0, 100, 0);" size="3">Delegate模式</font>可
供选择，一个方法类可以由它的访问子和工作子两个角色来完成，就像销售部门和生产部门一样。访问子还以原类名来命名，但是它不做实际的工作，只作实际工作
的准备工作（比如收集信息）和后续工作（比如转换结果），生产性的工作交给工作子完成，后者通常以原类名+Delegate命名。这样做的另一个好处就是
Delegate类可能很重磅，并面临大量的资源分配，因而可以懒加载。<br>
<br>
9。现在我们有了一个不错的体系结构，它包括一些轻量级的类、类的关系和设计模式，但是，不要以为这些东西是开始时就设计好了的，即使神仙也做不到那样，令人惊奇的是，它们都是从刚刚您写的一个名词开始的。^_^<br>
<br>
经常重构的泡泡<br>
<br>
<img src ="http://www.blogjava.net/briansun/aggbug/3205.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/briansun/" target="_blank">Brian Sun</a> 2005-04-13 10:54 <a href="http://www.blogjava.net/briansun/archive/2005/04/13/3205.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>我为Firefox正名</title><link>http://www.blogjava.net/briansun/archive/2005/04/08/3015.html</link><dc:creator>Brian Sun</dc:creator><author>Brian Sun</author><pubDate>Fri, 08 Apr 2005 15:53:00 GMT</pubDate><guid>http://www.blogjava.net/briansun/archive/2005/04/08/3015.html</guid><wfw:comment>http://www.blogjava.net/briansun/comments/3015.html</wfw:comment><comments>http://www.blogjava.net/briansun/archive/2005/04/08/3015.html#Feedback</comments><slash:comments>24</slash:comments><wfw:commentRss>http://www.blogjava.net/briansun/comments/commentRss/3015.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/briansun/services/trackbacks/3015.html</trackback:ping><description><![CDATA[最近接二连三看到好几篇讥讽Firefox的文章，文章的作者大都是拿出现在几款流行的浏览器软件相互比较一番，然后得出“Firefox无论性能还是功能都不够好”的结论，然后再说Firefox社区的网民都TMD“不够冷静”，国内国外都像炒股票似的把这个原本“不怎么样”的产品抄的沸沸扬扬，如此如此，这般这般，我真的实在是受不了了，是到了我们这些人出来为Firefox正名的时候了！<BR><BR>首先，我们从Firefox的来出看，Firefox是由Mozilla基金会开发的轻磅浏览器，在此之前，Mozilla已经有很多浏览器了， Mozilla Suite，Netscape都是Mozilla开发的浏览器。那么在这种情况下Mozilla为什么还要做这样一个浏览器呢？我给出的答案包括两个部分：有效性和必然性。有效性参看我的另一篇Blog[<A href="http://www.blogjava.net/briansun/archive/2005/02/26/1517.html"><IMG height=19 src="http://www.blogjava.net/Emoticons/coffee.gif" width=19 border=0></A>]。必然性则是因为Mozilla 迫切需要一个平台来展示他的思想、理念，并告诫正在以网页为经营手段的人们标准化的重要性！请永远记住下面这个等式：<BR><BR><FONT color=#ff0000 size=4><STRONG>开源软件基金会 ＝ 软件界的传道者</STRONG></FONT><BR><BR>他们做这些事情根本就是无利可图，只能依靠别人的捐助作为开发软件的成本。比如Firefox在刚刚上市放出beta的时候，为了扩大影响力， Mozilla决定登一则广告，于是四处筹集资金，最终从数千家赞助商那里筹集了25万美元的资金，并于2004年12月中旬在The New York Times上打了两个全版广告！你想想啊，数千家软件企业的期望，就为了这两个页面的广告如果说句不好听的话这两页纸会被多少人在上厕所的时候阅读然后索性用来擦屁股完全可以通过广告业的市调公司通过概率算出来！这是为了什么？我记得自己刚刚上网的时候就有人告诉我网络上什么人都有，但至少可以分为四种：商人、教父、狂热者和迷途青年。微软是彻彻底底的第一种人，Mozilla、Eclipse、Apache、JCP都是第二种，Maxthon是第三种，幸好这个世界还有传道者们的存在，否则我们都会变成第四种人，只会跟着商人和狂热者们走路。<BR><BR>是的，Mozilla正是要通过Firefox教诲我们他的圣经。有些人认为Firefox就是一个使用Gecko的Maxthon，我想说这些人大错特错，根本没有理解Firefox。引擎的不同是小事，遵从于标准才是正道。MSIE使用了大量的“专有技术”，使得别人针对MSIE开发的网站在标准化（一般指W3C标准）的浏览器上不能正常显示。也许有人会问，这个很重要吗？既然现在MSIE的用户数量如此庞大，那我们针对MSIE开发自己的网站又有什么错呢？答案是很重要！有错！我举个简单的例子，我们比较一下两个互为竞争对手的网站：IBM和Dell，他们都卖个人电脑，Dell的网站只能在 MSIE上正常显示，IBM的网站无论哪个浏览器都可以，这说明IBM遵循的是行业标准，而Dell使用的是微软特性。然后我们再看看他们两家公司的产品：IBM的电脑，捆绑什么操作系统的都有；而Dell的个人电脑，全部捆绑的是Microsoft Windows！还用我再解释吗？<BR><BR>有人认为Firefox占用太大内存了，我想问问他有没有用过Java，感受如何？Firefox占内存不是Firefox的问题，而恰恰在于操作系统 Windows的不合理性。Firefox的存在就有一个很重要的任务那就是跨平台，Firefox要用底层代码实现一个平台无关性体系结构，既是为了传道，更是为了那些从开源软件中收益的人们。有人认为Firefox结构太复杂，我想问问他有看过xpi文件的结构吗？xpi文件就是一个zip包！这一点又是Firefox从Java世界学来的，这还能叫复杂吗？比dll文件还复杂吗？Firefox还有比Java更绝的——允许插件使用COM！并且能在非Windows平台上虚拟出一个COM服务，这使得为Firefox编写插件变得更为简单，和可移植。如果Google为MSIE写了一个插件，那么他把这个插件移植到Firefox上的工作量只占10％。<BR><BR>有人认为Firefox功能太少，天哪，你不知道自己下插件啊！Firefox从一开始就没有把Maxthon作为自己的竞争对手，你知道是为什么吗？因为Maxthon在增强用户体验方面确实做的很好，而“Maxthon不足的地方不是Maxthon本身的问题，仅仅来源与它使用的是IE内核，所以 Maxthon会有很多安全性和稳定性方面的问题”。Firefox的对手是MSIE，为了更好的和对手较量，Firefox把增强用户体验的工作也交给了第三方插件开发商，毕竟Mozilla没有多少人手啊。Firefox所实现的都是不得不实现的，这恰是现代成熟的软件开发方法论所要教诲我们的。你看看：多页签是能力问题，换皮肤是架构问题，搜索条是易用性问题，DOM是规范化问题，JavaScript和XUL描述界面是平台无关性问题，XPCOM 是平滑迁移问题，而RSS则又是另外一个标准问题！哪一项是还可以从Firefox中剥离出去的？<BR><BR>至于插件吗，Firefox的主管说的很好，他说Firefox面世后只用了两个月的时间就获得了Maxthon花两年时间都没有的插件数量，这还不能说明问题吗？最近拜读了一位ACM老牛人写的关于插件服务的文章，其中提到良好的插件服务有两类，一类适用于单用户环境下大幅度提升可伸缩性，这种架构的完美实现就是Eclipse，另一类适用于多用户环境下大幅度提升安全性、稳定性和一致性，这种架构的完美实现就是Firefox。Firefox率先使用 RDF来描述插件，使用jar文件来打包资源描述，使用“中间定义语言”IDL来描述公共的COM接口，这些都是其它软件体系结构所没有的，也是大量软件架构师敢想而不敢做的！<BR><BR>最后一个问题就是Firefox不仅仅是个浏览器，还是一个RIA，就像Eclipse不仅是个IDE，还是个Platform一样。可以参考我的另一篇 Blog[<A href="http://www.blogjava.net/briansun/archive/2005/02/20/1364.html"><IMG height=19 src="http://www.blogjava.net/Emoticons/coffee.gif" width=19 border=0></A>]（我今天怎么老是做广告啊<IMG height=19 src="http://www.blogjava.net/Emoticons/red_smile.gif" width=19 border=0>），以后我还打算写更多关于RIA的文章。<BR><BR>在批驳了这些人的文章之后，让我们再来看看Firefox究竟是个怎样的产品。下面我仅仅列出我所看到的Firefox的优点，至于这些优点是否会让您迁移到Firefox平台，我并不奢求，这是您的价值取舍问题。<BR><BR style="FONT-WEIGHT: bold; FONT-FAMILY: courier new"><SPAN style="FONT-WEIGHT: bold; FONT-FAMILY: courier new">1。标准化。</SPAN><BR style="FONT-WEIGHT: bold; FONT-FAMILY: courier new"><BR style="FONT-WEIGHT: bold; FONT-FAMILY: courier new"><SPAN style="FONT-WEIGHT: bold; FONT-FAMILY: courier new">2。简洁化，最小内核化。</SPAN><BR style="FONT-WEIGHT: bold; FONT-FAMILY: courier new"><BR style="FONT-WEIGHT: bold; FONT-FAMILY: courier new"><SPAN style="FONT-WEIGHT: bold; FONT-FAMILY: courier new">3。平台无关性。</SPAN><BR style="FONT-WEIGHT: bold; FONT-FAMILY: courier new"><BR style="FONT-WEIGHT: bold; FONT-FAMILY: courier new"><SPAN style="FONT-WEIGHT: bold; FONT-FAMILY: courier new">4。安全型RIA。</SPAN><BR style="FONT-WEIGHT: bold; FONT-FAMILY: courier new"><BR style="FONT-WEIGHT: bold; FONT-FAMILY: courier new"><SPAN style="FONT-WEIGHT: bold; FONT-FAMILY: courier new">5。多用户环境下的插件管理。</SPAN><BR><BR>。。。。年轻人，开在我们有缘的份上，我决定卖这本&lt;&lt;如来神掌&gt;&gt;给你。。。什么？这本不合适啊？别急！还有很多本。。。。。。<BR><BR><BR>说三道四的泡泡<BR><BR><BR><img src ="http://www.blogjava.net/briansun/aggbug/3015.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/briansun/" target="_blank">Brian Sun</a> 2005-04-08 23:53 <a href="http://www.blogjava.net/briansun/archive/2005/04/08/3015.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>具有臭味的代码</title><link>http://www.blogjava.net/briansun/archive/2005/04/08/2972.html</link><dc:creator>Brian Sun</dc:creator><author>Brian Sun</author><pubDate>Thu, 07 Apr 2005 18:57:00 GMT</pubDate><guid>http://www.blogjava.net/briansun/archive/2005/04/08/2972.html</guid><wfw:comment>http://www.blogjava.net/briansun/comments/2972.html</wfw:comment><comments>http://www.blogjava.net/briansun/archive/2005/04/08/2972.html#Feedback</comments><slash:comments>5</slash:comments><wfw:commentRss>http://www.blogjava.net/briansun/comments/commentRss/2972.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/briansun/services/trackbacks/2972.html</trackback:ping><description><![CDATA[下面介绍几种具有坏味道的代码结构，其中很多经验学习自Eclipse，与Martin
Fowler不同的是，我找到的几种坏味道都存在于设计理念之中，而不是缺乏设计模式的抽象，也不是未重构的代码。先别急着反驳，也别急着嗤之以鼻，先想
想这些设计理念的优点，看看是不是微不足道，再看看这些理念的缺点，是不是有可能铸成大错，作者还给出了去掉这些坏味道的某个思路，即作者自己的思路，仅
供参考。最后，别忘了想想自己手中的软件的设计，看看会不会遇到其中的熟面孔啊。。。。。<br>
<br>
<span style="color: rgb(255, 0, 0); font-weight: bold;">1。味道：控件耦合。</span><br>
“如果第一个复选框被选中，那么下面的文本域全部失效。”通过这种方式表述的效果在软件开发中经常遇到，很多人称之为“界面逻辑”，想想看，界面逻辑真的可以直接变成代码吗？<br>
<span style="font-weight: bold; color: rgb(154, 205, 50);">典型重构思路：有限状态机。</span><br>
状态与控件属性集一一对应，控件属性被改变时，状态机收到事件，检查状态是否发生了迁移，如果是则向控件属性集的控制器发出状态迁移事件，控制器批量改变控件状态。<br>
<br>
<span style="color: rgb(255, 0, 0); font-weight: bold;">2。味道：控件/绘制器存在状态。</span><br>
有人认为Motif和Windows已经差别很大了，有没有想过它们和IBM收银机上的字符界面差别有多大呢？既然差别这么大的绘制器仍然存在相同的复杂了（有时是很复杂的）状态，那我们为什么不把它们extract出来而要让它们冗余呢？<br>
<span style="color: rgb(154, 205, 50); font-weight: bold;">典型重构思路：视图的模型。</span><br>
视图有视图的模型，并不是MVC中的模型，这种方式就是Swing的基础。<br>
<br>
<span style="color: rgb(255, 0, 0); font-weight: bold;">3。味道：视图发出有意义的事件。</span><br>
什么？你的意思是视图应该发出无意义的事件咯？不是这样吗？视图应该不了解任何业务逻辑，也不应该了解任何界面逻辑，如果界面逻辑真的存在的话。<br>
<span style="font-weight: bold; color: rgb(154, 205, 50);">典型重构思路：事件翻译器。</span><br>
视图发出无意义的事件，比如鼠标事件，键盘事件，或某个控件的事件，事件翻译器把低级事件翻译为高级事件，再把高级事件包装成请求，请求被传递给一个根控制器。<br>
<br>
<span style="color: rgb(255, 0, 0); font-weight: bold;">4。味道：动作/命令知道自己的形象。</span><br>
很多时候，一个Action或者一个Command都知道自己叫什么名字，能不能被禁用，有没有被禁用，图标如何，甚至还知道及时帮助的字符串，执行需要什么条件，返回什么结果等等，如果这么做的话Action和Command就有了自己的视图状态，发出了第2种味道。<br>
<span style="font-weight: bold; color: rgb(154, 205, 50);">典型重构思路：动作代理。</span><br>
重磅的工作交给代理完成，动作/命令只是一个视图的模型罢了。在UI系统装载之初，动作/命令被装载并绘制在界面上，直到用户点击或触发了这个动作/命令，它的代理才被调入并开始工作。<br>
<br>
<span style="color: rgb(255, 0, 0); font-weight: bold;">5。味道：模型知道自己的每一个用处。</span><br>
有n种视图对应同一个模型，比如对一个网页制作工具来说，一个html文件至少有三种视图：代码、设计、预览。如果模型同时能满足这三种视图的需求的话，这个模型就太重磅了，而且还不好添加一种新视图。比如Dreamwaver的代码/设计页面。<br>
<span style="font-weight: bold; color: rgb(154, 205, 50);">典型重构思路1：一个模型，多个维度。</span><br>
如果一个模型拥有n个维度，则n个对象，就可以确定一个事实，n-1个对象就可以得到一个线性聚集，n-2个对象就可以得到一个二维表。每个维度就是一组Interface,而事实的类型，其实是不可见的，（内部的巨大类型），只能通过维度确定事实，再提取事实的属性。<br>
典型重构思路2：适配器模式。<br>
模型首先实现最必要的接口，然后当需要模型实现某个非必要接口时，模型会主动或被动的适配为一个满足需求接口的“意外”对象。<br>
<br>
<span style="color: rgb(255, 0, 0); font-weight: bold;">6。味道：控制器变成顾问类。</span><br>
有些人认为我们的社会需要复合型的人才，因为每个人都要具备管理的能力，控制器也要懂管理，它要负责视图和模型之间的交互。但是仔细想想，如果被模型以外的对象知道了业务逻辑的话，那模型还可以替换吗？<br>
<span style="font-weight: bold; color: rgb(154, 205, 50);">典型重构思路：控制器标准化。</span><br>
控制器将请求包装为命令，并将命令交给命令堆栈执行。控制器并不了解模型，模型只能由模型自己了解，控制器也不知道领域逻辑，它只是做一些机械的翻译工作，并利用视图和模型提供的（互补相关）的素材，创建和模型相关的命令。<br>
<br style="color: rgb(255, 0, 0); font-weight: bold;">
<span style="color: rgb(255, 0, 0); font-weight: bold;">7。味道：模型变成无所不知博士。</span><br>
在没有发生上面六种情况的时候，千万不要大意啊，你很有可能发生了这一种情况，恰恰是因为控制器和视图都不知道业务逻辑，模型才有可能发展为Dr.Know。但是视图往往是树状结构的啊，它怎么和Dr.Know合作呢？通过代理？还是Facade？<br>
<span style="color: rgb(154, 205, 50); font-weight: bold;">典型重构思路：复杂模型结构（树状、图状、知识/操作分离）。</span><br>
如果有可能，模型也是树状的，可以和视图一一对应；如果这一点做不到，不要紧，可以把大模型划分成轻量小板块，或者迭代子，再用关系对象解释它们之间的关系；如果还不行，那总得做到知识和操作分离吧。。。。。。。<br>
<br>
做软件的泡泡<br>
<br>
<br>
<br>
<img src ="http://www.blogjava.net/briansun/aggbug/2972.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/briansun/" target="_blank">Brian Sun</a> 2005-04-08 02:57 <a href="http://www.blogjava.net/briansun/archive/2005/04/08/2972.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>4月4日评点Google</title><link>http://www.blogjava.net/briansun/archive/2005/04/04/2808.html</link><dc:creator>Brian Sun</dc:creator><author>Brian Sun</author><pubDate>Sun, 03 Apr 2005 16:04:00 GMT</pubDate><guid>http://www.blogjava.net/briansun/archive/2005/04/04/2808.html</guid><wfw:comment>http://www.blogjava.net/briansun/comments/2808.html</wfw:comment><comments>http://www.blogjava.net/briansun/archive/2005/04/04/2808.html#Feedback</comments><slash:comments>33</slash:comments><wfw:commentRss>http://www.blogjava.net/briansun/comments/commentRss/2808.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/briansun/services/trackbacks/2808.html</trackback:ping><description><![CDATA[终于有时间让我们冷静下来好好谈谈Google。好在现在是凌晨，我打开了窗户，这样很冷，但是可以让我的脑子更清醒一点，看看这个我们的生活已经离之不得的工具——尽管几年前我们还没有——看看它到底有什么可谈论的话题。<BR><BR>在我们谈论它之前首先我要感谢它，愚人节那天Google将我的邮箱升级到了2G，感谢它给我的这个节日礼物，尽管我半年内只用了5M。<BR><BR><FONT style="FONT-WEIGHT: bold; COLOR: rgb(255,0,0); FONT-FAMILY: courier new" size=4>1。Google以前做什么</FONT><BR>在Google出现之前人们只有一种搜索引擎，那就是分类引擎，这个想法来源于Yahoo，或者可以说来源于图书馆。后来人们在想如果网页不是由“人类” 添加上去的，而是“机器”自己找到的那该有多好，实现这个理想就意味要用大量的Spider搜寻整个互联网。<SPAN style="COLOR: rgb(0,100,0)">“嘿，等等，机器怎么知道鸡肉的味道？我是说它们很可能搞错了，这有可能是三文鱼的味道！”</SPAN>就像&lt;&lt;黑客帝国&gt;&gt;所担心的一样，Spider怎么才能知道我们需要什么能？于是有了动态的给每个网页评分的办法，这个办法就像小朋友们做游戏，别人对你的评价要远远重要于他们对你的拜访，PageRank就是这么来的，在结合了几种天才的想法和可行的技术细节之后，人类智慧的结晶，人工智能的当代经典，Google诞生了。<BR><BR>Google用大量的服务器（数以万计）做着每日的网页查找，每个线程就是一个Spider，每个Spider的工作就是从一个网页去另一个网页，检查他们是否已更新，是否废弃，是否存在新创建的页面，评价他们之间的关系，生成快照，并将数据存入数据库。Spider需要很好的协调以避免重复的劳动，同时他们需要确定工作范围的优先级，否则就会“跟不上时代的变化”或者干脆淹死在某些每秒种更新数千次的网页中。在确定了两张网页的关系之后，Google分别更新他们的PageRank得分，这个得分显然已经不是一个公式能够说清楚的了，它总是处在动态更新之中，但PageRank的大意就是，别人对你的连接数量越高你就越有价值，Google就越让你的位置靠前。<BR><BR>Google的出现使互联网的应用向前大大迈出了一步，大量可用性很强的信息资源立即出现在它的需求者面前。为此，权威的PC Magazine将Google和同一年出现的&lt;&lt;The Sims&gt;&gt;同时称为人工智能的经典作品。但也正是Google的这种优秀表现使人们开始了先知式的担忧，著名评论家Dvorak认为 Google的存在改变了以往“小公司大喇叭”的商业格局（借用了Chuck Martin的说法），它再次使互联网变成庸俗的经过资本市场洗礼的温顺绵羊，人们真正需要的东西可能会被排在后面或者根本找不到（比如我的Blog，<IMG height=19 src="http://www.blogjava.net/Emoticons/teeth_smile.gif" width=19 border=0>），而商业化的东西往往占据重要的位置（比如MSN的Blog！<IMG height=19 src="http://www.blogjava.net/Emoticons/cry_smile.gif" width=19 border=0>），最麻烦的是一旦人们依赖了Google，它就会不自然的扼杀人们对通过其它途径找寻信息的兴趣和勇气。从个人感情角度来讲，我认为这个论调是很有道理的，可这个问题的提出方式已经超出了本文讨论的范围，就像是一个生活态度问题：即使麦当劳再提供100倍的温馨服务，它也无法击败我家楼下买锅贴的；也不能指望USR公司自己维护NS-5机器人的安全，v这些都只能靠别人。同样，假如Google真的谋杀了互联网的本质，那么我相信拯救我们星球的会是一个更体现互联网本质的Hero，而不是Google自己。<BR><BR><FONT style="FONT-WEIGHT: bold; COLOR: rgb(255,165,0); FONT-FAMILY: courier new" size=4>2。Google后来做了什么</FONT><BR>正如我们所期望的，Google迅速成长为互联网企业的新兴代表，不断优化的引擎使我们获得了快速获取免费信息的途径，在一片叫好声中，Google开始向其它网络产品扩展。比如<A href="http://news.google.com/">Google新闻</A>，就是对Google这个巨大资源库的一种非结构化应用。现在Google新闻不仅有了搜索能力，还有了自动选择能力，这是在公开的抢报纸编辑的饭碗。再比如Google图像搜索，也为我们解决了不少难解决的问题，还有<A href="http://groups-beta.google.com/">Google Group</A>，这些服务使Google看起来更像Yahoo，或者MSN这样的门户网站，而事实上Google用来实现这些功能的成本比其竞争者要小的多，原因很简单，他们用的是人，Google用的是Spider！Google就像互联网领域里的Matrix，随处可见。<BR><BR>在提供了这些网络产品的同时，Google还在客户端与竞争者们一决高下，首先是浏览器的工具条<A href="http://toolbar.google.com/">Google Toolbar</A>，起初我觉得很有用，后来觉得没什么用占地方还损失性能，但是现在看到Firefox和Google结合的这么好，又开始使用了。然后Google推出了用于推广它自己的极好工具，这就是著名的<A href="http://code.google.com/">Google API</A>，在付出少许费用之后，你就可以在自己的程序里使用Google了（通常是Java），我曾经还一度想做一个Flash版的Google呢。此外还有用于处理“科学难题”的网格计算：<A href="http://toolbar.google.com/dc/offerdc.html">Google Compute</A>，模仿捐献家用计算能力以分析外星人电波的<A href="mailto:SETI@home">SETI@home</A>，后者由Stanford提供。<BR><BR><A href="http://froogle.google.com/">Froogle</A>也是一个伟大的设想，虽然它还没有中文版，但我已经领略到了它的能力。它提供一个商品的搜索引擎，让你可以在需要时浏览商品的价目和图片。这使得Froogle有时看起来很想<A href="http://www.ebay.com">ebay</A>，况且Froogle还有它的WAP版，也就是移动版。<A href="http://local.google.com/">Google Local</A>又是一个有价值的作品，它使得Google可以作为旅游指南或者地图使用。即使是Google的web搜索也有了很多衍生用法，比如瞧天气啦，找手机归属地啦，当计算器用啦，当词典用啦，反向搜索啦什么的。<BR><BR><FONT style="FONT-WEIGHT: bold; FONT-FAMILY: courier new" size=4><SPAN style="COLOR: rgb(0,128,0)">3。Google现在做什么</SPAN></FONT><BR>在客户端的竞争中Google并没有占到什么优势，MSN反而成了受益者，你想啊，搞软件设计谁能搞得过“买块肉SOFT”，Netscape、 Apple、IBM都尝试过，也不怕Google多尝试一次。但是Google却在这种内忧外患的情况下上了市，而且市场反映一片叫好！为了推陈出新，保持股价的攀升，Google采用了上市公司最喜欢华尔街最欣赏股民们最容易被欺骗的手法——虚伪扩张！一方面，Google大量投资研究操作系统、数据库和应用服务器这些网络商最赖以生存的技术；另一方面则投入大笔资金扩展业务领域，这种手段的优点是可以转嫁主营业务的成本和风险，做出更漂亮的财务报表，缺点是片面注重表面上的资源优化，往往错过改革技术和商业策略的最佳时机。<BR><BR>在Google陷入寻找新的扩展点而不能自拔时，一个新新人类的话题摆在了Google前进的道路上，这群人就是Blogger，他们要玩的就是Blog。说时迟，那时快！只见乌云密布，雷鸣电闪，咔喳一声晴天霹雳，Google站在<A href="http://www.blogger.com">Blogger.com</A>面前，笑里藏刀的说：“天下英雄，唯使君与操尔！”在收购了Blogger之后，Google基本放弃了它建造<A href="http://blog.google.com">blog.google.com</A>的计划。<BR><BR>2004年愚人节，对于网络邮箱供应商来说简直就是一个鬼节，这一天Google推出了它的<A href="http://gmail.google.com">Gmail服务BETA版</A>，它采用了非常具有神秘色彩并借助六度分隔和150法则而更具有神秘色彩的邀请发放方式。最令人头疼的是它提供1G的空间和压缩邮件（压缩意味着物理空间1G，而很多邮件供应商公布的空间是压缩之前的占用空间）。2005年的愚人节，Google更“丧心病狂”（开玩笑<IMG height=19 src="http://www.blogjava.net/Emoticons/coffee.gif" width=19 border=0>）的将这个数字增加到2G！跟进还是卖出？！这是其它邮箱供应商必须面对的一个抉择！<BR><BR><A href="http://desktop.google.com/">GDS（Google Desktop Search）</A>是Google的另一个重磅炸弹，这个是用来对付微软的。是的，你没听错！当微软在它下一版Windows（长角）的计划中露出新版文件搜索引擎的设想时，Google已经把成型的产品送到了客户面前。但是在试用了几次之后我有点纳闷，为什么这个备受好评的GDS在我的机器上跟Lucene 一样难用（对不起一次骂了两位<IMG height=19 src="http://www.blogjava.net/Emoticons/rose.gif" width=19 border=0>），它几乎搜不到什么有价值的文件——难道因为我用的是英文版？抑或是我没有掌握使用技巧？<BR><BR><FONT style="FONT-WEIGHT: bold" size=4><SPAN style="COLOR: rgb(238,130,238); FONT-FAMILY: courier new">4。Google遇到了什么困难</SPAN></FONT><BR>多少年来一个问题一直困扰着我，“一个以高科技著称于世的企业不会不在正面战场上胜过一个商业成熟的企业呢？”几乎每个受到工业革命和文艺复兴影响的人都会相信这句话。可恰恰是这句话导致了很多企业的失败。Google并未在正面击败Yahoo，相反，在与Yahoo的竞争中Google已经渐渐显出劣势的一面，这是由于“机器不能理解鸡肉的味道”的缘故吗？我们不得而知，但是有一点可以肯定，促使巴别塔停止建造的原因也在困扰着Google，简单的说就是全球化和本地化。在中文搜索引擎市场上，简体中文的第一是百度，其次是Yahoo，繁体中文的第一是Yahoo，其次是Google，日文版市场排名第一的还是Yahoo，第二名是MSN，俄文搜索引擎的老大也是俄罗斯的本地化引擎。面对这个局面，Google只能说OMG！（Oh！My God！）。下面这段文字摘自&lt;&lt;Google中文的三大软肋&gt;&gt;：<BR><BR><FONT color=#006400><FONT size=2>……据iResearch（艾瑞市场咨询）研究报告分析，百度仅用4年时间，远远领先于Google，百度拥有目前世界上最大的中文信息库，比Google中文更准确，更全面，快照功能也占优势……<BR>……雅虎一直很重视本地化，收购3721则是最好的一例。在国内市场上，3721的本地化购物搜索非常好，再上本地化的商业搜索，更具竞争优势。从某种意义上来说，3721网络实名的目录，就是一个典型的中国本地化企业产品的目录。所以说，拥有3721之后，雅虎如虎添翼，对Google构成了更大威胁……<BR>……在中文语言处理能力上，本地搜索公司的优势更让Google难堪。比如，《功夫》公映之前很久，在百度上检索“功夫”就能直接指向周星驰的电影，可是 Google搜索相同的“功夫”，则大失所望。因为这些时令性的关键词都需要专业团队去随时添加，由于Google缺乏专门针对中国市场的开发力量，尤其是对中国互联网信息检索存在的问题了解不透，所以，Google对于国内市场需求的反应速度很慢，本地化技术服务力量也跟不上，无法解决国内网民遇到的一些实际问题……<BR></FONT><BR></FONT>Google的新闻搜索也引来很大的争议，我们都知道如果一家媒体要摘录别人的新闻作为自己的新闻，那么他必须付费，可是如果这条新闻是搜索引擎搜出来的怎么办？如果这条新闻是和它的提供商几乎同时登出又怎么办？Google当然不会为他搜出来的每条新闻付费，而且，就像前面说的那样，Dvorak这样的同志又要大骂Google了，因为它扼杀了消费者冲浪的乐趣和获取别人没能及时获取的信息的喜悦感，以及Google的意志代替了互联网的意志等等。<BR><BR><FONT style="FONT-WEIGHT: bold; COLOR: rgb(0,0,255)" size=4><SPAN style="FONT-FAMILY: courier new">5。Google以后会做什么</SPAN></FONT><BR>目前还不知道Google下一步想做什么，但是我们都知道了资本的魔力和技术的信仰在控制着它，这使它成为人类有史以来最有想象力的公司之一。<BR><BR>我们猜想Google不久就会开放它的Gmail供人们随意申请，但申请时仍需要提供一个唯一的其它邮箱的帐号，（就像非Logitech的老鼠标加钱换新罗技，随意一款老洗衣机加钱换新荣事达一样），现在Gmail的策略是每个用户可以邀请50个新用户参加，此外每20人次的Google Web Search使用就会放出一个新的邀请。<BR><BR><A href="http://www.picasa.com/">Picasa</A>也将是Google发展的重头戏之一。前者是一个图片文件客户端，看起来好像很简单，肯定没有ACDSee做的好，但是在图片共享方面 Google可是从来没有放弃过啊。现在，Picasa又和Gmail结合到了一起，每个Gmail用户都可以用Picasa将图片上传到Gmail，这项功能大大加强了Picasa图片共享的能力。<BR><BR>此外，人工智能和大型计算技术也是Google发展的重要方向。不久之前Google发布了它的企业搜索服务器，虽然引来一路臭骂，但还是有一些专家认为这是个利好消息，说明Google正在别的盈利点上发觉自己的价值。概念已经有了，天价只是技术之不成熟性使然。这一趋势不仅可以从Google的产品上看出来，从Google的挖人策略也一样可见一斑。前不久，Google正式宣布它挖到了Java世界一只下金蛋的鹅——Joshua Bloch，这个人经常在我的梦中出现，要卖一本&lt;&lt;如来神掌&gt;&gt;给我！<IMG height=19 src="http://www.blogjava.net/Emoticons/confused_smile.gif" width=19 border=0>&nbsp;对不起，记错了，是一本&lt;&lt; Effective Java&gt;&gt;。说说J.Bloch的历史，可能很多人都会感到惊讶不已。他首先创造了曾在危难时期令整个Java世界恢复自信的Collection Framework，并获得了当年的Jolt大奖；后来为了让更多的Java程序员从Collection Framework的设计模式中收益（当时设计模式还不是很流行），他又以此为题写了&lt;&lt;Effective Java&gt;&gt;，并再次获得了Jolt大奖；为了在Java世界引入元模型的魔力，他继而提出了JSR175(A Metadata Facility for the JavaTM Programming Language)，并成为其首席专家；在Sun最危难的时刻挺身而出接掌Tiger（JDK 5.0）的大旗；在这之后，关于他的唯一新闻就是被Google挖走了。此外，Google还高薪挖走了无数把名字倒过来写我们都能认识的科学家， CSDN这样报道：<BR><BR><FONT color=#006400 size=2>……接着，Google又把BEA的首席架构师Adam Bosworth拢入自己旗下。Bosworth在软件行业作为技术主管受到广泛的尊敬。在为新创企业Crossgain（2001年被BEA收购）工作之前，Bosworth曾在微软任职数年，并成功地从事于一些项目的开发，如微软的Access数据库。<BR>他的跳槽来得太突然了，两个月以前，他还在供应商的“年度eWorld秀”中担任重要角色，并他的主题演讲中介绍Alchemy项目----一个建立下一代移动浏览器的计划。<BR>Google的招兵买马计划一直在有条不紊的进行着，曾在SUN微系统工作的David Stoutamire，现在在Google工作。就在上星期，Neal Gafter,SUN公司的javac主管，也离开SUN转向Google。<BR>不仅是Java方面，Greg Stein，曾是CollabNet项目经理,管理Subversion 项目并且发布了他们的SourceCast产品，现在在Google的博客软件组工作；Rob Pike，曾是贝尔实验室最初Unix团队成员之一,参与过Plan 9 和Inferno操作系统的开发，如今也投奔Google。<BR>Google一直渴求人才，对于开发者来说，Google也是一个充满吸引力的地方。他只雇佣最棒的、最聪明的、近乎于天才的那些家伙，在笼络人才这方面，也只有微软可与之媲美。最近Java人才不断涌入Google究竟是巧合，或是Google准备尝试基于Java做一些事情，我们拭目以待……<BR></FONT><BR>如果我没记错的话，Google前不久还从微软挖走了一位足可以称为WindowsNT之父的人，Google之野心路人皆知。看看下面这则招聘启事也许你就会更了解这一点了：<BR><BR>
<TABLE cellSpacing=0 cellPadding=1 width="95%" bgColor=#999999 border=0>
<TBODY>
<TR>
<TD>
<TABLE cellSpacing=0 cellPadding=2 width="100%" align=center bgColor=#ffffff border=0>
<TBODY>
<TR>
<TD>
<TABLE cellPadding=2 width="100%" border=0>
<TBODY>
<TR vAlign=top>
<TD colSpan=7><FONT size=-1><B>Passionate about these topics?</B> <A href="http://labs.google.com/why-google.html"><B>You should work at Google</B></A>.</FONT> <BR></TD></TR>
<TR vAlign=top>
<TD width="22%"><FONT size=-1>• algorithms<BR>• artificial intelligence <BR>• compiler optimization<BR>• computer architecture <BR>• computer graphics </FONT></TD>
<TD>&nbsp;</TD>
<TD width="22%"><FONT size=-1>• data compression <BR>• data mining<BR>• file system design <BR>• genetic algorithms <BR>• information retrieval </FONT></TD>
<TD>&nbsp;</TD>
<TD noWrap width="25%"><FONT size=-1>• machine learning<BR>• natural language processing <BR>• operating systems<BR>• profiling <BR>• robotics <BR></FONT></TD>
<TD>&nbsp;</TD>
<TD width="22%"><FONT size=-1>• text processing<BR>• user interface design <BR>• web information retrieval <BR>• and more! </FONT></TD></TR>
<TR vAlign=top>
<TD colSpan=7><FONT size=-1>Send your resume and a brief cover letter to <A href="mailto:great-engineers@google.com">great-engineers@google.com</A>.</FONT></TD></TR></TBODY></TABLE></TD></TR></TBODY></TABLE></TD></TR></TBODY></TABLE><BR><BR><FONT style="FONT-WEIGHT: bold; COLOR: rgb(128,0,128)" size=4><SPAN style="FONT-FAMILY: courier new">6。Google应该做什么</SPAN></FONT><BR>这一节我们将抛弃所有商业的想法，认认真真的坐下来考虑一下技术问题，当然，这会使得我们对Google的要求过高，我们会把很多未能被实现的我们曾经的梦想都交给未来的Google，就像我们把Sun没有做到的强加给IBM，把IBM没有做到的强加给微软，把微软没有做到的强加给Netscape，把Netscapge没有做到的强加给Yahoo一样。<BR><BR><STRONG>首先，Google应该认真考虑考虑<A href="http://www.w3.org/2001/sw/">语义网</A>的问题了，我个人仍然认为这是互联网发展的正道。</STRONG>虽然<A href="http://www.w3.org/RDF/">RDF</A>标准的发展雷声大雨点小，可是现在RSS已经如火如荼，这还只是语义网技术的一小部分，（就像WAP没什么用，但短信却发展起来一样），XSL和XSLT也是语义网的一小部分，它们将作为语义网与其展现之间的接口。我为什么要提语义网这个东西呢？举个例子你就能明白，比如我的Blog每篇文章每一页上都有菜单，都有最新评论、阅读排行榜和自定义列表，这些加速了访问者的效率，是富有亲和力的展现形式，但是对于Google来说这些都是垃圾，因为它们错误的表达了网页的含义，如果我要搜一篇阅读率极高的文章，可能搜出一堆没用的东西，而这些东西又不可能从页面上拿掉，所以Google必须自己去认。<BR><BR>反向快照可能是解决这个问题的临时方案。它的主要思想是Google首先发现别人是如何“描述”该网页的（通过链接的文字表达），再在该网页中找到与这个 “描述”相关的内容，把这部分内容作为该网页的高优先级内容，再把该网页与相同目录下的其它文件比较，将相同的部分列为低优先级的内容。（这是我个人想出来的方法，不知道可否奏效，估计可能会遇到性能问题<IMG height=19 src="http://www.blogjava.net/Emoticons/72_72.gif" width=19 border=0>）<BR><BR><STRONG>其次，Google将面临语义搜索的问题。</STRONG>这是MSN正在开发的技术，我相信Google也一定在做。这项技术的目的是让使用者同计算机之间的交互变得更人性化，看起来好像是用户像计算机提出了一个问题，计算机利用Google这颗大脑找到答案然后告知。哈哈，这个镜头是不是有点眼熟，它多次在好莱坞的电影中出现，比如&lt;&lt;AI&gt;&gt;中的Dr.Know（无所不知博士）和&lt;&lt;时间机器&gt;&gt;中的图书馆管理员，他们都是语义Google的愿景和Use Case。其中最有趣的是Dr.Know，他首先让用户选择类别，然后提问，问题按个数记费，答案往往只给出一个——当然是人工智能觉得最符合问题的一个。这提示了我们带类别的语义识别可能将成为语义识别技术迈出的第一步。再看看Google英文版目前提供的收费服务<A href="http://answers.google.com/">Google Answer</A>～～～有点意思吧？<BR><BR><STRONG>第三是模式学习。</STRONG>不客气的讲，Google一直在以自己的想法在搜索。不是吗？Google把Spider找到的所有页面都认为是资源，所以对其涵盖的内容一视同仁，对其表达的形式漠不关心，而正确的方式应该是将页面和搜索用户都看成用户，把页面人性化，从页面中吸取人类思维的模式，进行模式学习。这种技术给Google带来的好处是巨大的，其实现技术也简单于语义理解。打个比方，对于Sina被盛大收购，很多新闻网站都作为专题加以报道，而对于Google来说，要等很久才能把新浪和盛大这两个单词联系起来，这中间的时间包括其它由人来更新的网站的更新时滞，其它网站对这些网站的连接的更新时滞，这些更新被Spider发现的时滞，发现后PageRank更新到合理数值（中间可能经过多次迭代）的时滞等等。这使得Google明显慢于人的反映速度，这也就直接的造成了上面所提到的&lt;&lt;功夫&gt;&gt;不能及时搜到的原因。靠人工智能实现本地化，这是一条路。<BR><BR><STRONG>第四是信息源的深层发掘。</STRONG>这使得Google能触及互联网的死角，就像洗衣粉尽量触及衣物的死角一样，（“有汰渍，没污渍”<IMG height=20 src="http://www.blogjava.net/Emoticons/hitwall.gif" width=25 border=0>），例子很简单，如果我在网页中加入一段Javascript，就可以很容易把网页引到另一个地址，而这个地址很有可能是Google没有涉及到的，浏览器却可以访问。<BR><BR><STRONG>第五就是不得不提到的网格计算。</STRONG>因为Google的客户来自世界各地，一个日本人拜访Google和一个印第安人拜访Google在99.99％的概率上是不会访问相同内容的，因此将这两个人所要访问的内容放在一起实在是一种性能上的损失。最近听说Yahoo已经将中文搜索服务器迁到国内，这正是为了性能考虑的啊。当然，分布式服务器已经可以做到这一点了，那为什么还要网格呢？解释这个问题首先要从解释BT的原理开始，BT之所以让人们下载的那么快就是因为BT让Downloader成为其它Downloader的服务器，这种P2P的方式充分利用了Downloader的机器的计算能力和上行带宽。Google也可以做到这一点，例如我、我的邻居、李彦宏（百度总裁）<!--StartFragment -->和杨志远（Yahoo创始人之一）四人同时搜索了同一个关键字，假定服务器在中国，李彦宏首先获得了响应页面，我再访问时，Google通知我找李商量一下，李毫不犹豫的给了我页面，杨志远的请求收到处理，因为它不便于访问李彦宏或者我的机器，所以Google又给他开了一个响应页面，最后处理的是我的邻居，他的请求被推给了我，因为我们处在相同的子网内所以交流更为方便。原本四次的检索变成两次，即使加上两次简单的响应，总时间也大大缩短，假若我们四个人拜访Google的机会分别是10:10:2:1，结果就更不言自明了。如果Google在网格方面多追加一些研发资金，自然会比Yahoo做的好，这是由Google软件的架构决定的。<BR><BR><FONT size=4><FONT color=#800080><STRONG>写这篇文章花了我整整一天的时间，我写这篇文章的开始时间是4日凌晨0点04分，现在已经快到5日的0点04分了，可是我还意犹未尽，为了不影响手头上的工作我决定就此打住，如果您有什么想法，请回帖指教，谢谢。</STRONG></FONT><BR></FONT><BR>累死了的泡泡<BR><BR><img src ="http://www.blogjava.net/briansun/aggbug/2808.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/briansun/" target="_blank">Brian Sun</a> 2005-04-04 00:04 <a href="http://www.blogjava.net/briansun/archive/2005/04/04/2808.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>插件片段和功能部件</title><link>http://www.blogjava.net/briansun/archive/2005/03/30/2616.html</link><dc:creator>Brian Sun</dc:creator><author>Brian Sun</author><pubDate>Wed, 30 Mar 2005 10:11:00 GMT</pubDate><guid>http://www.blogjava.net/briansun/archive/2005/03/30/2616.html</guid><wfw:comment>http://www.blogjava.net/briansun/comments/2616.html</wfw:comment><comments>http://www.blogjava.net/briansun/archive/2005/03/30/2616.html#Feedback</comments><slash:comments>11</slash:comments><wfw:commentRss>http://www.blogjava.net/briansun/comments/commentRss/2616.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/briansun/services/trackbacks/2616.html</trackback:ping><description><![CDATA[插件片段和功能部件<br>
<br>
[参考：http://www.uml.org.cn/zjjs/zjjs24.htm]<br>
[参考：http://www-900.ibm.com/developerWorks/cn/linux/opensource/os-ecfeat/index.shtml]<br>
<br>
Eclipse 由插件组成，但在开发 Eclipse 的插件时，还要慎重考虑另外两个级别的组件 — 插件片段和功能部件。<br>
<br>
插件片段（如名称所暗示的）是完整插件的组成部分 —
目标插件。片段提供的功能与目标插件的功能合并。片段可以用于将插件本地化成各种语言；在无需形成一个全新发行版的情况下，以增量形式将功能部件添加到现
有插件，或者提供特定于平台的功能。在许多方面，片段与插件一样。主要的区别就是片段没有插件类 —
片段的生命周期由其目标插件管理。此外，片段的清单文件叫作 fragment.xml，它列出了目标插件的标识和版本号，以及片段的标识和版本号。<br>
<br>
另一方面，插件功能部件根本不包含编码。在 Eclipse 体系结构术语中，功能部件是将一组相关插件打包到完整的产品中。例如，JDT 是包含了象
Java 编辑器、调试器和控制台这样的插件的功能部件。名为 feature.xml
的清单文件描述了一个功能部件归档文件。在其中，该清单文件包含了对该功能部件所包含的插件和其它资源的引用、关于如何更新该功能部件的信息、版权信息和
许可证信息。<br>
<br>
如果没有功能部件，插件是难以驾驭的，通俗地说，不属于功能部件的插件是未被管理的插件。Eclipse
平台的启动过程包括一个配置的步骤。如果一个新的插件被拷贝到 \plugins 目录，或者以其他方式使 Eclipse
在启动的时候可以找到，配置过程会发现它，但只是通过将新插件的 splash 图标闪烁两次来通知您。Eclipse
之所以会发现新的插件，是因为存贮在 \.metadate\.config\platform
中的当前工作区的配置校验和发生了变化；由于您没有向平台提供一个可以引导用户做出配置修改的功能部件，Eclipse 也只能是通过
splash-flash 来提示这一变化。将您的插件打包为一个（或两个）功能部件，您将获得如下好处：<br>
<br>
&nbsp;&nbsp;&nbsp; * 在 Eclipse 的配置过程中列出您的组件（在 feature.xml 文件中）所要求的先决条件<br>
&nbsp;&nbsp;&nbsp; * 使您的组件可以作为 Eclipse 配置的活动部分来管理<br>
&nbsp;&nbsp;&nbsp; * 创建标记信息，让使用那些使用运行期环境的用户可以识别您的组件，并通过一个欢迎页面来告知用户您的功能部件所提供的功能（在关联到您的功能部件的 welcome.xml 文件中）<br>
&nbsp;&nbsp;&nbsp; * 用 Eclipse 更新管理器可以对您的组件进行修改<br>
<br>
不要等到您的插件开发完成后再打包为功能部件。反映在功能部件定义中的设计结果会影响您如何构建您的插件。例如，大多数的 Eclipse 组件都有
UI 功能部件和核心（不是
UI）功能部件。如果您的插件没有按这种方法进行划分，您可能会马上考虑重新设计它们。功能部件也可以用来自动编译处理被引用的插件。<br>
<br>
<img src ="http://www.blogjava.net/briansun/aggbug/2616.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/briansun/" target="_blank">Brian Sun</a> 2005-03-30 18:11 <a href="http://www.blogjava.net/briansun/archive/2005/03/30/2616.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>关于个体软件过程</title><link>http://www.blogjava.net/briansun/archive/2005/03/26/2489.html</link><dc:creator>Brian Sun</dc:creator><author>Brian Sun</author><pubDate>Sat, 26 Mar 2005 14:02:00 GMT</pubDate><guid>http://www.blogjava.net/briansun/archive/2005/03/26/2489.html</guid><wfw:comment>http://www.blogjava.net/briansun/comments/2489.html</wfw:comment><comments>http://www.blogjava.net/briansun/archive/2005/03/26/2489.html#Feedback</comments><slash:comments>5</slash:comments><wfw:commentRss>http://www.blogjava.net/briansun/comments/commentRss/2489.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/briansun/services/trackbacks/2489.html</trackback:ping><description><![CDATA[这是我在我租的房子里第一次上网，从前天到今天，在经历了Modem战役、Modem电源战役、拨号软件战役、电话线战役、用户名和密码战役、ADSL分频器战役、死机战役等等战役之后，终于在今天下午14点整登上了分别已久的Blog。<br>
<br>
这两天在读一本讲RUP的书，这本书的所有案例都是围绕软件<span style="font-weight: bold;">PSP Tools</span>开发的全过程展开的，（猜对了，就是<span style="font-weight: bold;">&lt;&lt;小型团队软件开发&gt;&gt;</span>！），因为已经很久没听人讲过PSP了，所以倍感亲切，一时间免不了多了些感想，记了下来，与大家分享。<br>
<br><span style="font-weight: bold;">
PSP者，个体软件过程也。</span>第一次跟朋友提到PSP时，朋友问“要那玩意有啥用？”我当时就愣住了，半天没说出个所以然来，我还真不知道该怎样回答这么突
如其来的问题，或者应该说我还真没想到回有人问出这样的问题来。朋友的理由也很坦荡，讲过程就要讲团队如何把握过程，这样才能减少沟通的成本，降低开发的
风险；讲一个人的过程有什么意思，每个人都有每个人的思维方式，尤其是脑力劳动者，更是需要工作形式的个性化和多元化。这样看来朋友是站在“脑力劳动者”
的立场上说话的，我也完全有理由相信脑力劳动者大多数都是这样认为的。那我呢？我站在谁的立场上？是“体力劳动者”吗？朋友说“你是站在管理者的立场上才
那样说的，因为管理者总是希望每个人都把精力集中在提升自己的工作效率上。”<br>
<br>
这一番争论我至今记忆犹新，真的是朋友所说的那样吗？CMM、RUP、XP和PSP是目前软件过程标准的四个代表，<span style="font-weight: bold;">RUP（Rational统一过程）</span>产自IBM/Rational公司，这个公司的创始人来自电信领域的软件巨头；<span style="font-weight: bold;">XP（极限编程）</span>来自Kent Beck和Martin Fowler，他们是软件设计和软件工程领域的世界名人；<span style="font-weight: bold;">CMM（能力成熟度模型）</span>与PSP
同一个父亲，即美国著名的软件界人士Humphrey先生，军方曾希望Humphrey先生能为其选择软件供应商制定一套衡量软件开发能力的标准，SEI
和CMM就诞生了，卡耐基梅隆大学希望Humphrey先生能为软件系的大一新生写一本可以规划其一生职业发展的书，PSP应运而生。四个标准的创始人代
表了四类对过程感兴趣的人群：大客户、管理者、开发高手、职业学者。可见我并不是站在管理者的角度，（虽然我是哈伯德的支持者），大家的立场不同，看到的
软件过程也就不同，不信，你比较一下。大客户多数在乎的是规范、透明和稳定性，如果一个人离开了项目，项目能否继续？如果所有的人都离开了项目，项目能否
继续？如果一个企业离开了项目，项目能否继续？管理者看重的是成本、风险和进度的等边三角形，考虑到质量的管理者就更为出色。开发人员，包括分析人员、设
计人员、实施人员和测试人员，都希望项目的任何工作都好上手，不要纸上谈兵，要重视人（自己）而不是过程，要重视产品而不是文档。唯独职业学者最不一样，
他所想的往往是你所发现不到的问题，因为他们常常不在项目中，多数是在项目完成之后的谈论和数字中得到启发，因此他们看到的也可能是你最需要但自己却不知
道的Best Practise。<br>
<br>
为了证明我的观点，我找了一个很好的例子。我们项目组目前正在使用脑图相互交流思想，和记录头脑风暴的结果。<span style="font-weight: bold;">脑图（MindMap(R)）</span>是
托尼·巴赞的注册商标，他为什么要注册这样一个商标呢？在托尼年轻的时候，他去图书馆找教人如何使用大脑的书，图书馆管理员认为他是个怪人“哪有人不会用
大脑的呢？”于是带他去了“脑内科”的书架，托尼知道管理员是不会理解他的，于是他决定自己去找。他花费了数年的时间，找遍了全国所有著名的和不著名的图
书馆，（他好像是英国人），都没有找到一本教人如何使用大脑的书。托尼突然有了一种使命感，既然上帝让他领悟到大脑的使用是有技巧的，那他就有义务将这个
发现告诉更多的人。这种使命感就像促使奥格曼迪诺写成<span style="font-weight: bold;">&lt;&lt;世界上最伟大的推销员&gt;&gt;</span>一样，促使托尼花费了毕生的精力，经过无数次的调查和研究，终于发明了脑图，并成立了人类历史上第一个以研究如何使用大脑为目标的国际性组织。今天，脑图已经家喻户晓，它对人类文明的贡献绝不亚于希尔博士的<span style="font-weight: bold;">&lt;&lt;Think And Grow Rich&gt;&gt;（&lt;&lt;思考致富&gt;&gt;）</span>，但与后者不同的是，托尼不仅因此而获得了崇高的威望，还获得了惊人的财富，这完全得益于他为脑图注册了商标。（想想吧，每份Visio和每本<span style="font-weight: bold;">&lt;&lt;学习的革命&gt;&gt;</span>都付了版权费用！）<br>
<br>
几十年来，托尼帮助过无数的人，帮助他们改掉不良的思维习惯，帮助他们找到最合适自己的工作，帮助他们提高自己的能力和收入，他为人类创造的价值，岂是亿
万可以衡量。这个例子用来证明我的观点，似乎是用了宰牛刀，既然研究如何使用自己的大脑都如此有价值，那么研究一个自己的开发过程和开发能力又何尝不必要
呢？<br>
<br>
我读过很多托尼的书，我觉得如果说希尔教人如何完善心态，奥格教人如何培养习惯，卡耐基教人如何沟通交流的话，那么托尼就教人如何使用大脑，他们共同构成
了美国式的成功学最基础的四步曲。这些不是哈伯德所说的商业道德，而是一套种子如何成长为大树的指南。回到我们所谈论的话题上来，如果以每个人的思维方式
不同为理由，就可以放弃改进自己思维习惯的话，那这个人一定不能成为成功者！事实上，每个人的心态、每个人的习惯、每个人说话的方式、每个人如何使用大
脑、甚至每个人心目中的道德观念这些都是不同的，且会有很大差异，然而这恰恰是区别一个成功人士与其它人的最重要的差别。<br>
<br>
最后，我希望留给中国所有每个开发人员（包括我自己）一个最美好的祝福，希望每个人都能成为成功人士。当然这是不可能的，这个世界上总是失败平庸者居多，功成名就者居少，其原因，就是没有注意这些成功人士应该注意的地方。<br>
<br>
爱读书的泡泡<br>
<img src ="http://www.blogjava.net/briansun/aggbug/2489.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/briansun/" target="_blank">Brian Sun</a> 2005-03-26 22:02 <a href="http://www.blogjava.net/briansun/archive/2005/03/26/2489.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>也谈UI包装</title><link>http://www.blogjava.net/briansun/archive/2005/03/23/2349.html</link><dc:creator>Brian Sun</dc:creator><author>Brian Sun</author><pubDate>Tue, 22 Mar 2005 17:26:00 GMT</pubDate><guid>http://www.blogjava.net/briansun/archive/2005/03/23/2349.html</guid><wfw:comment>http://www.blogjava.net/briansun/comments/2349.html</wfw:comment><comments>http://www.blogjava.net/briansun/archive/2005/03/23/2349.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.blogjava.net/briansun/comments/commentRss/2349.html</wfw:commentRss><trackback:ping>http://www.blogjava.net/briansun/services/trackbacks/2349.html</trackback:ping><description><![CDATA[以前的几次帖子中，我们都谈到了在UI平台的设计过程中常常会使用的一种设计模式，就是封装，但是封装是一种极难把握的模式，而且，单单使用封装往往也起不到任何设计效果，有时还会画蛇添足，那么，大师们是怎么使用封装的呢，我们看看Java领域的例子。<br><br><font color="#ff0000" face="Courier New" size="5"><strong>Swing</strong></font>是
由Sun的优秀科学家和Netscape的杰出设计师共同创造出来的卓越的架构。它一生下来就拥有皇族血统，但注定一生都不会取得王位。现在崇拜
Eclipse设计架构的人比较多（包括我），随之而来的是对Swing的批评声也很多（不包括我），其实这是一种错误的认识，就像
Smalltalk是一种很优秀但使用较少的语言，VB和Foxpro则属于那种天生拙劣但使用广泛的语言。Swing比Eclipse架构早出来好几
年，后者从前者那里吸取了不少的经验，也借鉴了很多模式，才会有今天的成就。而直到今天Swing仍然有很多值得我们学习的地方。<br><br>再说封
装，打开JButton的源代码就会发现，JButton没有往可怜的Windows界面上画上任何一笔，换句话说，整个类里面一行绘图代码都没有，这是
为什么？因为JButton是一个Controller的变种，绘图组件由另一个类提供，这个类以UI名字结尾，在内部包中，且绘图器在不同的界面风格
下、不同的操作系统、甚至不同的语种下面有不同的实现。这使得JButton类四两拨千斤，凭一个不变的框架同时实现了跨平台和可插拔风格。至于它的一些
显示参数，别着急，既然有C有V不可能没有M啊，ButtonModel类负责维护JButton的参数。<br><br>我们再看卓越的Eclipse，Eclipse比其这种封装来说就要复杂的多了，我们分成六个环节来讲。<br><br><font color="#a52a2a" face="Courier New"><strong>1。</strong></font>Eclipse将Windows的绘制方法包装成<font color="#a52a2a" face="Courier New" size="5"><strong>SWT</strong></font>，这种包装很原始，但是很有效，因为Java不好调用Win32API，所以这一步实现了跨平台。需要注意的是，这种包装应该属于简单的分层，Eclipse编写了一个操作系统的Facade，OS类，这个类的win32版的源代码有2734行，显然是个庞然大物啦。<br><br><font color="#ffa500" face="Courier New"><strong>2。</strong></font>Eclipse把SWT当作它的基本组件来重用，（就好像这是别人写的东西），它把SWT的组件继续包装成<font color="#ffa500" face="Courier New" size="5"><strong>JFace</strong></font>，JFace采用真正意义上的 MVC模式，比起紧凑的SWT来要活泼一点。JFace把SWT当成它的View，把Provider的实现当作它的Model，把自己包里的可控的带有组件逻辑的Viewer类当成Controller。<br><br><font color="#008000" face="Courier New"><strong>3。</strong></font>由于SWT被设计用来绘制窗体组件，按照管理，应该有一个包被用来绘制二维图形，这个工作就交给<font color="#008000" face="Courier New" size="5"><strong>Draw2D</strong></font>来完成，它被放置在GEF包中，和SWT 处在一个层次。需要注意的是，Draw2D与SWT的组织机制不同（见<a href="http:%20//www.blogjava.net/briansun/archive/2005/02/26/1518.html"><u>前面的文章</u></a>）。<br><br><font color="#0000ff" face="Courier New"><strong>4。</strong></font>Eclipse继续封装，因为JFace只解决了高级组件的问题，并不能直接放在Workbench里面用，所以Eclipse制作了<font color="#0000ff" face="Courier New" size="5"><strong>Workbench</strong></font>包，这个包把Viewer封装成ViewPart，它认为Viewer是绘制器，而ContentProvider是Model，所以，像之前的几次一样，ViewPart变成了Controller。<br><br><font color="#800080" face="Courier New"><strong>5。</strong></font>有了ViewPart也就有了EditorPart，这两种Part都有可能要显示<font color="#800080" face="Courier New" size="5"><strong>Form</strong></font><font color="#000000">表单</font>（一
种类似HTML的界面），表单上的控件——理所当然，是由
SWT实现的——与一般意义上的控件有很大的不同，这种不同主要体现在展现方式和事件通知上。Eclipse采取的方式是另做一套内部实现，包装SWT实
现，比如SWT有一个Button，表单包也有一个表单Button，与Button通过一个Toolkit类转换。这种方式就是设计模式中提到的
Proxy。<br><br><font color="#ee82ee" face="Courier New"><strong>6。</strong></font>现在我们再看看需要绘二维图的EditorPart，这个部分是通过<font color="#ee82ee" face="Courier New" size="5"><strong>GEF</strong></font>来实现的，GEF是比JFace和Workbench更严格的MVC，它再EditorPart的基础上再包装一次，将策略等控件业务与控件绘制分离。<br><br><font color="#008000" size="4"><strong>今
天我得到的最重要的一个结论，就是封装是相对的，MVC也是相对的，因此在JFace看来是Controller的东西在Workbench来看可能是
View，这可能导致在设计时的大量争议。今天的另一个收获是发现了封装也有几类，我能想到的应该有Facade封装、Proxy封装、MVC封装三种，
你还能想到更多的吗？<br></strong></font><br>做软件的泡泡<br><br><br><br><img src ="http://www.blogjava.net/briansun/aggbug/2349.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.blogjava.net/briansun/" target="_blank">Brian Sun</a> 2005-03-23 01:26 <a href="http://www.blogjava.net/briansun/archive/2005/03/23/2349.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item></channel></rss>