这张图的意思大致也就是说，目前的图书中，关于Java, Java EE的书简直就是多如牛毛，而关于Ruby和RoR的书只有2本（我现在在看的，算是第3本吧，O'Reilly也有一本关于RoR的书，算是第4本）。 但是RoR这个新应用框架却正在以狂风暴雨之势席卷 Web 开发社区，特别是Java和PHP。

汇总一下网上的以及自己从书中看到的资料:

1. 什么是Ruby?
   

   Matsumoto Yukihiro （"Matz"）是Ruby这个编程语言的发明人，他从1993年起便开始着手Ruby的研发工作，1993年2月24日Ruby诞生，1995年12月Matz推出了Ruby的第一个版本Ruby 0.95。Ruby 是一种动态编程语言，它在许多方面类似于 Perl、Python 和 Smalltalk，但是它是自成体系的，Ruby成功的组合了Smalltalk的优雅以及Python的易用性，还有Perl的实用主义。Java 和 PHP 编程人员应该可以很轻松的掌握这一语言。

   Ruby 的历史不短，先于在1995 年便为公众知晓的 Java 和 PHP。所以尽管 Ruby 是一个成熟的语言，却不如其它语言普及。这造成了 Ruby 编程语言阵营并不如 Java、PHP 和 Perl 阵营强大（这也是上面这张图展示出来的现状）。

2. 什么是Rails?
   

   Rails是一个用来开发以数据库为后台的Web应用的开源框架。 David Heinemeier Hanson 发明的 Rails 框架是 Ruby 诞生以来最受欢迎的应用程序，Ruby 社区推广能力不济的颓势也得到了扭转。Rails 将 Ruby 编程语言扩展为极其适用于 Web 开发的领域特定语言。它还借用了 ActiveRecord 扩展，将对象关系持久性引入了 Ruby 语言。

   Rails使用了严格的 Model-View-Controller (模式-视图-控制器)体系结构，赢得了自尊且醉心于设计模式的Java程序员的尊敬 - 这是 J2EE 开发人员对其情有独钟的原因； 同时 Rails 可以非常方便地构建基础系统 - 这是它吸引 PHP 开发人员的原因。

   但Rails有它自己的一些薄弱的地方: 从数据库角度来看，Rails 有一些非常明显的缺陷。Rails 对数据库布局和应用程序需求作了许多假定。比如，Rails 假定所有表都使用一个非复合的主键。它不支持复合主键也不支持双步提交（two-phase commit），它只能用于单个数据库后端的情况。

3. RoR的优势?
   

   Ruby on Rails最大的优点就是在于简单！RoR的核心思想就是"更少的编程，更简单的配置！"

   • 安装和配置非常简单，不象Java需要安装运行环境，安装应用服务器，然后再进行一大堆的配置。Ruby只需要装一个简单的解释环境就可以了。RoR避免了繁杂的XML配置文件，你的应用程序和数据库里已经包含了所有Rails需要的东西。
   • 编码简单，很多代码都是可以自动生成，可以自动生成MVC，可以自动生成框架、Web服务。甚至你只要写上一行代码就可以实现以前使用Java上百行代码的工作量，越少的编程量就意味着越少的bug。
   
   
4. RoR稳定吗，适合企业应用吗?

   企业应用需要的是稳定和高效。 Ruby和PHP一样，属于解释性语言。 目前使用PHP来开发的Web应用，适合于企业应用的不少，blog系统和讨论组系统也都大量使用PHP。 配合Ruby的RoR在效率上应该没有什么问题。 至于稳定性，目前还没有什么实际的数据可以来讨论。

【相关链接】

Ruby: http://www.ruby-lang.org/en/
Rails: http://www.rubyonrails.org/

Groovy is a dynamic language for the JVM that integrates seamlessly with the Java platform. It offers a Java-like syntax, with language features inspired by Smalltalk, Python or Ruby, and lets your reuse all your Java libraries and protect the investment you made in Java skills, tools or application servers.

很早以前就曾经关注过Groovy，还在Ruby和Groovy中犹豫过。 目前虽然在看一些Ruby和RoR的书籍和资料，Groovy还是不会忽略掉的，当然还有Grails，这个以Groovy写成的Web应用框架 (Groovy + Grails & Ruby + Rails)。

【相关链接】

下载Groovy: http://dist.codehaus.org/groovy/distributions

About Groovy: http://www.aboutgroovy.com/item/list

Eclipse的org.eclipse.help.internal.appserver包中，含有一个重要的类：WebappManager，几乎所有和Tomcat相关的操作，都和这个WebappManager有关，其中比较重要的几个方法是：

1. getHost()，返回运行Tomcat的主机名或者IP地址
2. getPort()，返回Tomcat监听的端口号，这个端口号在每次Tomcat启动时，都不一样
3. start(String webappName, String pluginId, IPath path)，启动应用程序，其中的pluginId为包含web应用的插件ID（后面做详细解释）

在了解了基本的方法以后，我们可以实验一下：

1. 创建一个插件(plug-in): com.kompakar.webapp，这个插件可以不需要UI的支持
2. 插件com.kompakar.webapp需要依赖以下Eclipse插件：
3. 1. org.eclipse.help.appserver
   2. org.eclipse.help.base
4. 在com.kompakar.webapp目录下面，建立WEB-INF，WEB-INF/lib和WEB-INF/classes目录。 这里的WEB-INF目录结构和普通的web application完全一致，用于存放你的JSP，Servlet和classes。 如果你的web application需要其他库的支持，那么放在WEB-INF/lib下面。
5. 启动Tomcat: WebappManager.start("myapp", "com.kompakar.webapp", Path.EMPTY); 在启动方法中:
6. 1. 第一个参数myapp就是web application的上下文目录；
   2. 第二个参数就是包含了web application的插件ID；
7. 得到完整的URL: "http://" + WebappManager.getHost() + ":" + WebappManager.getPort();
8. 1. 这个操作返回的结果可能是：http://127.0.0.1:52235，最后的端口号是随机的

OK，如果你启动了你的插件，并且在WEB-INF下面有一个简单的index.jsp的话，打开你的浏览器，打开: http://127.0.0.1:52235/myapp，那么你就可以看到你的index.jsp了。 如果你的插件同时捆绑了Eclipse的Web Browser插件的话，你就可以在你的插件里打开浏览器，直接访问你的web application了。

这样做有什么好处吗？ 其中的一个好处是，你可以把支持web的报表系统（比如BIRT)安装在一个特殊的插件中，那么你的桌面RCP系统就有一个支持web的报表系统了，你可以通过启动Tomcat来使用你的报表。

【参考文章】Use Embedded Tomcat in Eclipse for a Webapp

Technorati : eclipse

Eclipse需要保持竞争力，关键也在于开发和使用者的这个社团。 Eclipse的plug-in架构，已经保证了这个社群会很快的成长（因为会有大量的开发者去写plug-in），大公司（如IBM，BEA，Borland）的加入和支持，也扩大了Eclipse的知名度，使得更多的开发者加入进去。 但是如何更好的融合这个社群，如何保证Eclipse的核心基础架构不受外部的困惑（变得更加庞大，或者臃肿）但又会不断创新，如何协调好Eclipse和其他Eclipse.org下面的顶级项目（如BIRT，WTP，AspectJ等）的整合关系，这些，确实也值得思考。

对interface编程，这个似乎是个老生常谈的问题了，但是却从来没有思考过，这种编程方式会影响到这个开发团队的协同工作，特别是一个超过10人的开发团队，而对一个分布在不同地方的开发团队（比如项目外包以后，不同的开发小组位于不同的城市，甚至国家），这种编程方式带来的影响更大。

为什么会这样呢？ 在一个只有3-4人的开发团队里面，任何的改动，可以快速的通知其他的人，而且，现在IDE中的重构工具会解决大部分的工作。 但是，当一个开发团队变大的时候，通常就会分成小组，不同的小组对不同的部分负责。 在这种情况下，你在自己的模块中发布了API，你就必须确保这个API是稳定的。“Once you have published an API then it is your responsibility to keep them stable. Otherwise you will break the other components and nobody is able to make progress. Having stable APIs is a key to making progress in a project of this size.” 所以这是一个是否把API发布以及发布了以后如何维护的问题：“So it's the difference, as Martin Fowler would say, between public and published. Something can be public, but that doesn't mean you have published it. ” 即使定义了API，公开发布(publish)和这个API是公共的(public)是有区别的：API公开发布以后，就需要非常的小心，因为任何的API改动都可能会破坏其他在使用这个API的代码。

Email this store to a friend (send a short email with a subject to this story)
Subscribe to kukooBlog (subscribe kukooBlog's RSS feed)
Send me feedback on this story

Eclipse，Design Pattern
Programming

将陆续更新一些心得。

第三部分的原文。

Software，Design Pattern
Programming

I just noticed that String#substring(…) shares the underlying char array. So if you have a big string, take a substring of it, throw away the big string, you will still hold on the big char array. A simple way to solve this is to make a copy of the substring using the String(String) constructor.

I saved 550KB in JDT Core by changing the following code:

String simpleName =
fullyQualifiedName.substring(fullQualifiedName.lastIndexOf('.'));

to

String simpleName = new
String(fullyQualifiedName.substring(fullQualifiedName.lastIndexOf('.'))); 

Eclipse3.1发布以后，使用者发现，3.1占据了大量的Heap（大约200-300M）。Eclipse的开发小组正在不断地解决这个问题，而String#substing的改进，将在Eclipse 3.1M6中发布(4月1日)。

这个提示，其实也可以运用在我们自己的项目之中

[Note: This blog was migrated from my old CSDN blog.]

为什么重发这个blog呢？因为昨天看到Eclipse.org网站上关于Eclipse Performance的一个文档。这份文档主要是提示，在开发基于Eclipse的应用时（不管是Eclipse程序本身，还是Plug-in），在性能问题上需要注意的一些地方。其中，第一条就是如何使用substring()的问题。Eclipse 3.1M7以及RC1，都已经进行了这方面的调整，所以现在的Eclipse，对Heap的占用已经大幅减少，从而在性能上也有所提高。

Eclipse.org
eclipsepowered.org

Email this store to a friend (send a short email with a subject to this story)
Subscribe to kukooBlog (subscribe kukooBlog's RSS feed)
Send me feedback on this story

Eclipse，Java
Eclipse，Programming

RDE
About Ruby

Software Programming，Ruby
Programming

..... The business layer should be responsible for the following:

• Handling application business logic and business validation
• Managing transactions
• Allowing interfaces for interaction with other layers
• Managing dependencies between business level objects
• Adding flexibility between the presentation and the persistence layer so they do not directly communicate with each other
• Exposing a context to the business layer from the presentation layer to obtain business services
  Managing implementations from the business logic to the persistence layer

Excerpt from "Wiring Your Web Application with Open Source Java" by Mark Eagle

[Note：This blog was migrated from my very old blog which was in the blogspirit.]

Software Programming，Open Source
Programming

• Managing requests and responses for a user.
• Providing a controller to delegate calls to business logic and other upstream processes.
• Handling exceptions from other tiers that throw exceptions to a Struts Action.
• Assembling a model that can be presented in a view.
• Performing UI validation.

Here are some items that are often coded using Struts but should not be associated with the presentation layer:

• Direct communication with the database, such as JDBC calls.
• Business logic and validation related to your application.
• Transaction management.
• Introducing this type of code in the presentation layer leads to type coupling and cumbersome maintenance.

Excerpt from "Wiring Your Web Application with Open Source Java" by Mark Eagle

[Note：This blog was migrated from my very old blog which was in the blogspirit.]

Software Programming，Open Source
Programming

• Querying relational information into objects. Hibernate does this through an OO query language called HQL, or by using an expressive criteria API. HQL is very similar to SQL except you use objects instead of tables and fields instead of columns. There are some new specific HQL language elements to learn; however, they are easy to understand and well documented. HQL is a natural language to use for querying objects that require a small learning curve.
• Saving, updating, and deleting information stored in a database.
• Advanced object-to-relational mapping frameworks like Hibernate have support for most major SQL databases, and they support parent/child relationships, transactions, inheritance, and polymorphism.

Here are some items that should be avoided in the persistence layer:

• Business logic should be in a higher layer of your application. Only data access operations should be permitted.
• You should not have persistence logic coupled with your presentation logic. Avoid logic in presentation components such as JSPs or servlet-based classes that communicate with data access directly.

By isolating persistence logic into its own layer, the application becomes flexible to change without affecting code in other layers. For example, Hibernate could be replaced with another persistence framework or API without modification to the code in any other layer.

Excerpt from "Wiring Your Web Application with Open Source Java" by Mark Eagle

[Note：This blog was migrated from my very old blog which was in the blogspirit.]

Software Programming, Open Source
Programming

Bruce原来的blog: On the Thought就是我常看的一个blog之一，原因不仅仅是因为Bruce是Think in Java的作者，他也在blog中发表了相当有意思的帖子。

而Aitima的blog系统也挺有意思的：你发表评论的时候，像是在一个论坛里面（那种很像BBS的论坛）。我没有找到如何trackeback Bruce的weblog，但是这种发表评论的作法，确实新颖。按照Bruce的介绍，在发表评论的时候，也不是任何东西都可以发表的（要不就变成了“blog spam”），因为Aritima Blog建立了一种机制，“keep the discussions civilized ”，而且Artima更注重开发者。这两点，是Bruce迁移他的blog的原因。

如果你也关注Bruce Eckel，去他新的Webblog吧。

Bruce Eckel的homepage
Bruce Eckel的Weblog Feed

blog，Software Programming
Blog/RSS，Programming

我第一接触Struts，大约在2001年的年中。那时候，我刚好结束了一个项目（我的第一个J2EE项目），基本上是以Sun的PetStore的设计思想开发的（其实，PetStore已经含有MVC 2的思想了）。我的一个朋友推荐我看看Struts。我一下子就被Struts简单，灵活而又高效的设计思路吸引了，特别是看到ActionForm可以“自动的”得到页面的输入，而不需要自己写大量的request.getAttribute()的时候，几乎喜出望外了。当时，还没有足够多的Struts的资料，市面上可以买到的，也只有O'Reilley出版的唯一的一本关于Struts的书籍。但是我还是毫不犹豫地在第二个项目中使用了Struts。到如今，我参与的所有的项目，都是基于Struts的。

5岁的小p孩儿，会走，会说话，刚刚进幼儿园。而5岁的Struts，现在是Java世界里，开发Web应用程序的默认框架标准。在书店里，你可以找到大量的关于Struts的书，Struts的资料也是浩如烟海。说它“如日中天”可能也不为过。

然而，Struts也有它不足的地方（比如重用ActionForm和Action比较麻烦），而同时新的技术又在不断涌现，5年（或者说3年）以后，会是什么样子呢？下一代的Web应用框架，会是JSF吗?（JSF的作者就是Craig R. McClanahan）或者，真的如Craig说的，JSF应该和Struts协同工作，而不是替换掉Struts。

看看TheServerside上面大家的评论吧。

Struts on Apache
Comments on TheServerside
5 Year Anniversary of the Birth of Struts
Sean's stack trace on Struts 5 Years .

Java，Software Programming
Eclipse， Programming

      重用的最高境界是什么？我们创建一个非常高层的，面向具体应用的框架，然后只要做简单的客户化，并且重用这个框架中现有的设计。（“We thought the way to create software was to build high-level, domain-specific frameworks, and then you just customize them and reuse all the design that is codified into them. That was the reuse nirvana.”）但是，连Eric都意识到，这太理想化了，因为 “ I have learned that it's hard to create highly reusable frameworks.”

      在谈到可重用的framework的时候，Eric提到了Eclipse:

      那么，什么又是Controlled extensibility呢？为什么要对扩展性进行控制呢？

      Eric对于重用，定义了三个级别：最低一级，重用类（classes）；最高一级，框架（framework）；而中间一级，就是设计模式（Design Pattern）（“This is where I see patterns. Design patterns are both smaller and more abstract than frameworks. They're really a description about how a couple of classes can relate to each other and interact with each other. The level of reuse increases when you move from classes to patterns and finally frameworks. ”

      Eric提到了一个有趣的现象。通常，我们拿到一个需求，会先做设计，做设计的时候，我们会使用设计模式（Design Pattern）。但是，使用XP （eXtreme Programming）方式的人不这样做，他们先写测试（“They write a test”）

      那么，设计一个framework的时候，要注意什么呢？要避免frameworkitis. （“ Frameworks abstract and provide higher level default functionality. To do so the framework needs to be in control. This loss of control can lead to what is sometimes called frameworkitis. ”）

      而且，一个framework要做的比较小，因为，如果framework太大了，那么它可能就会做太多（可能会frameworkitis），而且，不容易学习，学习曲线太长，也不容易维护。

      Eria的论述真是非常精彩，而且也解释了Eclipse的一些内部设计。一定要阅读全文

[Update] 感谢lxwde的中文翻译。我的中文翻译可能不完全准确。中文翻译，请参考Related Links中给出的lxwde的中文翻译链接。




Artima developer
访谈的第一部分
如何思考Design Pattern?
CSDN上的中文翻译

Email this store to a friend (send a short email with a subject to this story)
Subscribe to kukooBlog (subscribe kukooBlog's RSS feed)
Send me feedback on this story

Software，Design Pattern，Eclipse
Programming, Eclipse

“The complainer may talk about how this means that you can't tell if a particular team is using an agile method or not. They may also say that this makes it hard to teach people how to do agile methods - what's the curriculum?”（这些抱怨者指出他们很难区分是否在使用敏捷方法，也很难用固定的课程去教授如何使用敏捷方法）

然而，没有一个严格的定义，正是敏捷方法的核心哲学 （“This lack of rigorousness is part of the defining nature of agile methods, part of its core philosophy.”）

Martin接着指出：

“Different kinds of systems have different kinds of pressures and forces, which makes it very difficult to come up with a rigorous statement of what to do that's sufficient to cover them.”（不同的系统有来自不同方面的压力，这种情况使得很难定义出一个严格的过程，去定义如何有效的解决这些问题）

而另一关键的问题是：人，软件开发的主体，是一个最大的可变的因素 （“This effect is compounded by the fact that software development is such a people-oriented activity, and people are naturally inconsistent and highly variable. ”）

倡导敏捷方法的人，之所以没有为敏捷方法制定出一个严格的定义，就是为了将软件开发中最大的可变因素，而又是过程的执行者：人，忽略掉。（“ that's its not effective to try and bind software development to a rigorous process, because that's ignoring the essential nature of the primary (human) components that will execute that process”）

阅读全文

Martin Fowler
inconsistent and highly variable

Email this store to a friend (send a short email with a subject to this story)
Subscribe to kukooBlog (subscribe kukooBlog's RSS feed)
Send me feedback on this story

Software，Agile Programming
Programming

作者提到了几个有趣的事实。首先，基于浏览器的Web Application让IT部门的员工爱不释手，因为真正的“零客户端管理”实现了，服务器端的任何一点改动在客户端立刻就可以使用了，而不需要每个客户端都再去维护了。但是，除了这个好处之外，还有其他什么吗？用户，包括IT部门的员工逐渐就意识到了，有了易于管理的好处，但是牺牲了可用性，许多非常好用的功能，比如鼠标右键的快捷菜单，按列重新排序，调节列的宽度等等，都在Web Application中失去了。而事实上，仔细想想，为什么大多数的用户更愿意使用Outlook，ThunderBird这样的邮件客户端，而不是mail.yahoo.com这样的浏览器邮件客户端。而同时，浏览器下的Web Application没有一个统一的应用程序的风格，菜单放哪里？上面，底下，左下角？

再回来看看所谓的“零管理”。J2SE 1.4中加强了Java WebStart的功能。这种分布式的做法，使得客户端每次启动执行的时候，都会从服务器下载最新的版本。这样，不是解决了“零管理”的问题了吗？其实还有一些需要注意的问题：下载多少？如果每次都要下载好几兆的更新，通常用户的接受不了。想想每次更新Windows的补丁，就知道下载好几兆的更新是一种什么感受了。

所以，真正的网络客户端，应该是“瘦”的，但是“功能丰富的”，或者说，是“thin”而且“rich”。“thin”是指相对于传统的“fat”客户端（象Office这样的“胖客户端”），在客户端不需要太多的安装，“rich”则是指相对于当前的Web Application，应该是功能丰富的。当前的Web Application是“thin”的，但是不够“rich”。

那么何去何从呢？
一个选择是Mozilla 的XUL，一个跨平台的UI解决方案；
一个选择是Eclipse的RCP，足够的“rich”了，但是不够“thin”: RCP的运行库就达到了6.7M了，似乎胖了点。

看完这个blog，只有两个想法：

其一，RCP应该会是一个很大的发展方向。需要下载安装的客户端对于高速的宽带网络来说，不是问题；
其二，Java WebStart的应用，每次客户端启动，只会更新改动过的部分（除非客户清除了客户端的缓存）。这样的话，6.7M的RCP运行库并不是每次都需要更新的。

有了Java WebStart，Web Application所称道的“零客户端管理”就不再是一个显著的优势了。而RCP却带来了Web Application所不具备的用户易用性，统一的风格和传统桌面程序中所熟悉的功能。

Wolfgang Paulus 是 SwixML （一个开源的XUL引擎）的创始者和主要作者。也许Wolfgang更乐于看到XUL 和 RCP 都会健康的发展，提供开发真正的“Thin Rich Web Application”的平台。

Wolfgang Paulus's blog
SwixML

Email this store to a friend (send a short email with a subject to this story)
Subscribe to kukooBlog (subscribe kukooBlog's RSS feed)
Send me feedback on this story

Eclipse，RCP
Eclipse，Programming

SmallTalk将快要完成它的历史使命了，而任何一种语言，不管是Java还是C#，都不可能永远存活下去的。技术主导不了市场，新的需求会催生新的语言。

Richard Monson-Haefel的Blog：IBM abandons Smalltalk

Email this story to a friend (send a short email with a subject to this story)
Subscribe to kukooBlog (subscribe kukooBlog's RSS feed)
Send me feedback on this story

SmallTalk

Bobby Woolf 在他的blog中提出了使用Data Obfuscator（混淆数据）：即通过一个特定的程序，特定的一组算法和规则，从用户的数据中摘取足够的数据量，同时，把一些敏感的数据（如姓名，薪水，保险号码等）替换成一些不重要（或者不敏感）的数据（比如，把姓名用A001, A002来替换掉）。

Data Obfuscator 原文参考

Design Pattern
Programming

Bill Venners将把这次访谈的内容分多次，发表在Artima Developer上。Erich Gamma的论述确实精彩，他不仅谈到了当初如何进入Design Pattern这个领域的过程，也谈到了在他开发JUnit的过程中，如何设计JUnit，以及如何在JUnit中使用Design Pattern。

“Do not start immediately throwing patterns into a design, but use them as you go and understand more of the problem. Because of this I really like to use patterns after the fact, refactoring to patterns. ….. Trying to use all the patterns is a bad thing, because you will end up with synthetic designs—speculative designs that have flexibility that no one needs. These days software is too complex. We can't afford to speculate what else it should do. We need to really focus on what it needs. ” 

“We didn't just string patterns together when we designed JUnit. We did it test-driven, starting with a test that we wanted to succeed and once it passed we looked into how we could improve the code. ”

Who is Erich Gamma?（这个问题好像问的有些傻）

《Design Patterns: Elements of Reusable Object-Oriented Software》，《Contributing to Eclipse: Principles, Patterns, and Plug-Ins》的作者之一；JUnit的作者之一；Eclipse JDT的负责人。他目前在IBM的瑞士苏黎世OTI实验室工作。 

[Update]感谢的lxwde中文翻译。



第一次访谈的详细内容。
Artima Developer
CSDN 上的中文翻译

Email this store to a friend (send a short email with a subject to this story)
Subscribe to kukooBlog (subscribe kukooBlog's RSS feed)
Send me feedback on this story

Design Pattern
Programming

特别是Geronimo! Part1，详细描述了Geronimo的系统结构。而Geronimo的开发，相比之前，似乎加快了不少，第二篇文章中就介绍了IBM开发的用于Geronimo的一个Eclipse构件，但是需要和Eclipse WTP一同工作。希望Eclipse WTP可以把这个plug-in包含到WTP里面。

Eclipse，Geronimo