把握现在，把握未来—2008 Java开发展望

过去的十二个月给来年预示了什么呢？

By Andrew, JavaWorld.com 01/24/08

译者：ginge


The future is now -- Java development in 2008
What do the past 12 months tell us about the year ahead?
By Andrew Glover, JavaWorld.com, 01/24/08


the year 2007 was full of exciting plot twists, punctuated by growing excitement about dynamic languages, the open source evolution of the JVM, and the rise of Google as a strategic contributor to the Java community. The question is, what does all that tell us about the year ahead? Andrew Glover has some answers for Java developers who need to know -- now! -- what's coming in 2008.
2007充满了激荡人心的事件，动态语言的不断升温，JVM在开源社区不断发展以及Java社区的重要贡献者，Google的崛起等。问题是，这些预示了来年什么呢？安德鲁•格勒弗（Andrew Glover）准备了一些答案给那些打破砂锅问到底的Java开发者――现在，什么在2008接踵而至。


French poet Paul Valery once lamented that "the trouble with our times is that the future is not what it used to be." Valery's comment was uttered years ago, yet his words are timeless for those of us living in the age of the Internet, fueled by the rise of the Java platform.
法国诗人保尔•瓦雷里曾经伤心地写下“困扰我们这个时代的是，未来，并不像过去看上去的那样”。然而，对于我们这些生活在Java平台崛起推动的互联网时代的人来说，瓦雷里多年前留下的这些诗句是永恒的。

in the span of a little more than a decade we've seen Java applets come and go. We've seen the apparent demise of EJB, the rise of JSF, Spring, and Struts (not to mention the beginnings of Strut's slow decline), and the redefinition of Java itself into both a language and a platform. The Java platform has split into three branches (Standard, Enterprise, and Micro) and the JDK has been released to the open source community. The Java language has expanded to include annotations, generics, enumerations, advanced collections, and more. It has also begun to share its home, the JRE, with dynamic languages like Groovy, JRuby, and Rhino, to name a few. In fact, if you think about it, especially over the last few years, we've collectively watched as the moniker of Java has transformed from a language into a veritable platform.
过去的十多年，我们见证了Java Applet的兴起和没落，见证了EJB头顶上光环的不断暗淡，见证了JSF，Spring和Struts的异军突起（暂且不谈Struts渐渐显露的颓势），见证了Java已经重新定义成为一种语言和一个平台。Java平台已经衍生出三个分支（标准版本，企业版本，微型版本），JDK也开放给了开源社区。Java语言扩充了，包含了注解，范型，枚举类型，高级集合类型，还有更多。它也开始与动态语言，如Groovy，JRuby和Rhino等，共享Java运行时（JRE）。事实上，如果稍稍留神一下，我们在过去的几年里注视着Java不断地从一种语言演变成为一个真正的平台。


What we've learned in the last decade is that Java is much more than a language or a platform: It's a community. It's an economic ecosystem. It's a living, breathing entity that has matured and grown into a veritable lifeline for a cornucopia of applications, and for large and small companies alike.
在最近的十年里，我们知道Java已经不仅仅局限于一种语言或者一个平台了：它是一个社区，一个经济生态系统，一个鲜活的实体，而且这个实体已经发展成熟，成为了丰富的应用程序，或大或小公司的真正的生命线。


And so, despite some rumors to the contrary, I would argue that Java isn't going anywhere but up in 2008. Rather than peer into a crystal ball and try to divine the future, let's reflect on the major events and trends of the past year. Taken together, they reveal all we need to know about what's ahead in 2008.
因此，尽管流言不少，我还是坚持认为Java在2008会持续红火。与其拿起卦子掐算未来，我们不如回顾一下过去的一年的趋势以及发生的重大事件。这些事件汇集起来，它们会告诉我们2008将发生什么。

Halcyon days
遍地开花

The year 2007 was a roller-coaster ride driven, most dramatically, by growing interest in dynamic languages, the open source evolution of the JVM, and the rise of Google as a strategic contributor to the Java community. What's more, wider adoption of unit testing, continuous integration, and other agile development techniques suggests that Java developers are beginning to view our craft as a profession that requires accountability. We are finally starting to focus on the quality and longevity of our code as much as its speed to market or immediate applicability in the enterprise.
2007年犹如过山车一样，非常引人注目。人们对动态语言的不断关注， JVM在开源社区不断发展以及Java社区的重要贡献者，Google的崛起。更多的是，单元测试，持续化集成和其他敏捷开发技术得到了更广泛的接受，这些都表面Java开发者开始认识到我们的技艺是一门有责任要求的行业。我们终于开始重视代码的质量和寿命，将其与推向市场的速度，或者是在企业的即时应用放到同等重要的地位上来。

All told, 2007 was a year of some clear triumphs, as well as some disappointments and squabbles that made for more bumps along the way than some in the Java community had anticipated. Consider the following major factors that shaped the year behind us.
每个人都说，2007年有一些绝对的胜利，但是同时也有一些失望和争论，这给Java社区产生了超出预期更多的阻碍。留心一下以下这些体现过去一年的重大因素。


Dynamic languages come of age
动态语言的成熟

Groovy reached a pivotal milestone in 2007 with its 1.0 release, followed in short order by Groovy 1.5. Having come a long way over the course of five or so years, Groovy is positioned as an additional language for the JRE, not a replacement for the Java language.
随着1.0以及随后的1.5版本的发布，Groovy在2007的发展达到了一个关键的里程碑。走过过去5年或者多年的历程，Groovy没有替代Java，相反定位成了Java运行时（JRE）的补充语言。

Groovy's big selling point is its shorthand syntax, which simplifies everyday programming activities. For instance, opening and reading a file is a typically verbose construct to code in normal Java:
Groovy的大卖点是简练的语法，简化了日常的开发工作。例如，打开和读取一个文件在Java语言是典型的冗长结构：

try {
     BufferedReader in = new BufferedReader(
        new FileReader(path));
     String line;
     while((line = in.readLine()) != null){
       System.out.println(line);
     }
     in.close();
    }catch(IOException e){
      System.err.println("Exception reading");
    }

But the same code in Groovy can be written much more quickly:
但是同样的代码，Groovy可以写的更加敏捷：

new File(path).eachLine{ line ->
     println line
}

Basically, Groovy (like other dynamic languages) permits you to drop exception handling, types, and semi-colons, and even permits more concise coding constructs that make the code ultimately easier to read (yes, that File object above is Java's java.io.File).
根本上，Groovy，像其他动态语言一样，可以让你你扔掉异常处理，类型和分号，还可以使得代码更加简练，而代码简练最终使得代码的可读性更强（是的，上面那个File对象是一个Java java.io.File对象）。


Cast your net wide
把网撒开
Groovy wasn't the only player on the dynamic language block in 2007, however. Java 6 (released in 2006) introduced a standard API for interacting with dynamic languages, which many Java developers began exploring in earnest late last year. The flagship integration for that API was Rhino, but it seems that more engines will be integrated with the Java 7 release.
然而， Groovy并不是2007年动态语言阵营的唯一参与者。2006年发布的Java 6版本引入了一个与动态语言交互的标准API，很多Java开发者在去年临近年底才开始体验。对该API进行旗舰式集成的是Rhino。但是，看起来在Java7版本发布时还会有更多集成进来。

One of the first languages slated for integration is undoubtedly JRuby, which rose to rapid prominence with its 1.0 release and the surprising realization that it is faster than Ruby itself! Like Groovy, JRuby (which allows Ruby to run on the JVM and interact with normal Java objects) makes Java development simpler by permitting a more relaxed syntax and adding a wee bit of magic. For example, using Ruby allows you to enhance normal objects, such as Ruby's String to do things perhaps a bit more easily. In normal Java, checking if a String instance is blank may require using a method like what's below (which is the Apache commons-lang implementation of isBlank).
最早进行集成的语言之一不容置疑是JRuby，1.0版本的发布和令人咋舌的比Ruby本身运行速度还快的实现，使得它备受瞩目。像Groovy一样，由于可以使用更加宽松的语法，加入了一些特殊机制的JRuby（它可以使RubyJVM里运行，且与正常的Java对象交互）使Java开发更加简单。例如，使用Ruby可以增强标准的对象，象用Ruby的String操作会更加容易。在标准的Java里，检查一个String实例是否为空值可能要做象如下方法的一样的操作（这是一个Apache commons-lang的 isBlank实现）。

public static boolean isBlank(String str) {
 int strLen;
 if (str == null || (strLen = str.length()) == 0) {
  return true;
 }
 for (int i = 0; i < strLen; i++) {
  if ((Character.isWhitespace(str.charAt(i)) == false)) {
   return false;
  }
 }
 return true;
}

String in Java is a final class, so you can't extend it to add a new enhanced string type to support an isBlank method, for instance. Consequently, you have to rely on a separate library, like common-lang. With Ruby, you can alternatively define a blank? method on Ruby's String object itself, like so:
在Java里，String是一个final类，所以你无法为了让String类型支持一个象isBlank的方法而扩展它。后果是，你不得不依赖第三方类库，象common-lang。有了Ruby，你就可以在Ruby的String上另外定义一个blank?方法，如：

class String
 def blank?
  empty? || strip.empty?
 end
end

Ruby's style of dynamism permits adding behavior (like adding a blank? method to String) to core libraries -- or any object, in fact -- at runtime. What's more, with JRuby you can retroactively add methods to core Java objects, too. Thus it takes just a little magic to add a blank? method to Java's String class!
实际上，Ruby式的动态允许运行时添加额外的行为到核心类库或任意对象（象给String增加一个blank?方法）。更进一步，JRuby可以进行反作用对核心Java对象增加方法。因此，稍一施法就可以给Java String类添加一个blank?方法。


Opening up the heart
开放Java核心
The open sourcing of Java last year means that the evolution of the Java platform is no longer solely in the hands of core Sun engineers: now it is up to all of us. OpenJDK, which embodies a GPL license around the Java class library, javac, and even the JVM itself, promises to usher in a whole new cycle of innovation -- in fact, we're already seeing it.
去年Java的开源意味Java平台的发展不再由Sun核心工程师们说了算了：现在它的前途由我们掌握了。对Java类库，Javac，甚至JVM本身都采取GPL协议，OpenJDK保证将会开创一个创新的周期。实际上，我们已经看到了。

In October of 2007, a project dubbed Multi-Language VM was proposed under the OpenJDK charter. The aim of this project is to mollify the underlying infrastructure of Java for "prototyping JVM features aimed at efficiently supporting languages other than Java." Clearly, this initiative blends two of last year's most exciting developments -- that is, the enthusiasm surrounding dynamic languages and the OpenJDK -- to usher in a new age of innovation at the heart of Java.
在2007年十月，一个名为Multi-Language VM的项目在OpenJDK旗下开展了。这个项目旨在通过修改Java的底层架构，实现“以JVM特性为原型，高效支持Java之外的语言”。很明显，这项目结合了去年最令人振奋的两个发展潮流，也就是围绕在动态语言的热衷和OpenJDK，这宣称我们处在了一个Java核心创新的时代。

Sun's openness certainly didn't start with the OpenJDK project -- Glassfish, a Sun supported open source application server, also continued to gain a wider community throughout 2007. More recently, it is impossible to ignore Sun's acquisition of MySQL AB, the corporate entity behind MySQL, which is arguably the prevailing open source database today.
Sun的开放当然不是从OpenJDk开始的，而是Glassfish，作为Sun支持的开源应用服务器，它在2007自始至终获得了社区更多的追捧。最近，我们无法忽略Sun对MySQL AB的收购， MySQL背后的公司是MySQL AB，而MySQL似乎是当今最流行的开源数据库。


All of these developments suggest that Java's progenitor is embracing a business model that leverages open source software in a big way, which means we can look forward to seeing more openness in the Java platform in 2008 and beyond. Of course, all of this may have far-reaching consequences for commercial aspects of the Java ecosystem -- which thus far appears to be quite healthy given Oracle's recent 7 billion dollar purchase of BEA.
所有这些发展都表明Java的鼻祖采取了一种受开源软件很大影响的商业模式。这意味我们在2008或者更远将看到Java平台更多的开放。当然，这会对Java生态系统的商业方面产生深远影响。相比最近Oracle以70十亿美金收购BEA，这似乎很绿色，很健康。


Google flexes
Google flexes
In late 2007 the mobile Java landscape, which had recently been somewhat scorched, was reinvigorated by the announcement of Google's Android platform. Android aims to bring software applications to a new breed of mobile devices running an open source OS primarily led by Google. While Android is an entire platform (much like Java), the SDK for building Android applications is built on Java.
移动Java领域曾经变的不景气，但是临近2007年尾时，却因Google的Android平台的发布而重焕青春。Android的目标是为新一代移动设备引入应用软件，且运行在由Google主导的开源操作系统之上。虽然Android是一个完整的平台（很像Java），但是构建Android应用程序的SDK却是建立在Java之上。

Moreover, Android's Java is distinctly different from the Java of J2ME. In fact, the underlying JVM for Android is unique as far as JVMs go: it doesn't run normal Java bytecode but a highly optimized format designed just for Android. Having multiple implementations of Java running on mobile devices means that we'll most likely be seeing some interesting applications -- which of course only adds to the ubiquity of the Java platform.
此外，Android的Java与J2ME的Java截然不同。实际上，在JVM层面，Android的JVM就已相当独特了。除了运行专门为Android而设计，高度优化的字节码格式的代码，它不可以运行标准Java字节码。移动设备上运行不同实现的Java意味这我们将可以看到一些有趣的应用程序――当然，这也仅进一步说明了Java的无处不在。


Google's hand in Java went well beyond mobility in 2007, however. Of particular interest was the release of Guice, an open source dependency injection framework built on top of Java 5's annotations and generics. While the big dog in the IOC market is still Spring, at the time of Guice's public release it was a trailblazer, eschewing XML files in favor of annotations and Guice's own Module types.
2007年Google在Java世界移动领域之外也进展的很顺利。但是，备受关注的是Guice的发布，Guice是一个基于Java 5注解和范型的依赖注入开源框架。虽然IOC市场上的佼佼者还是Spring，因其摒弃XML文件，提倡使用注解和Guice本身的Module类型，注定了Guice在公开发布时就是一个先行者。

Given the weight of Google behind a second-generation IOC framework and the fact that Guice is relied upon for Google's own AdWords infrastructure, it's a good bet that it will continue to gain mindshare in the next year.
考虑到Google对第二代IOC框架的影响和Google AdWrods本身的基础架构都是依赖Guice的，Guice在来年很有可能将得到更多的关注。

Agility goes mainstream -- testing arrives!
敏捷成为主流――测试时代到来了

The term agile isn't new, nor are the practices of unit testing and continuous integration. Nonetheless, 2007 appears to be have been the year these practices became more mainstream. You couldn't attend a conference without encountering one or more presentations focused on agility. More telling, a quick scan of the 2008 Jolt Awards finalists (which are chosen in 2007) for General Books and Technical Books shows a solid foothold for books about unit testing and continuous integration. Most important of all, however, is the fact that both established frameworks and new players to the field have begun to tout how easy their particular architecture is to test! It seems that developer testing has finally arrived.

敏捷（agile）这个名称对大家来说并不新鲜，单元测试与持续化集成也不陌生。不过，2007年似乎是这些实践更加成为主流的年份。你不会碰到一个会议里没有一到两个关注在敏捷上的演示的。再哆嗦几句，瞥一眼2008年度Jolt Award大奖关于综合性和技术性书籍（从2007年甄选的）的最终名单，就可以看出关于单元测试和持续化集成的书籍占有一席之地。然而，更重要的是，不管是享有盛誉的，还是刚刚发展的框架都已经开始宣称它们的架构是多么容易地进行测试了。似乎，开发人员的测试时代终于到来了。


Java's growing pains
Java成长之痛

While it's clear that Java is becoming more a platform than just a language, the Java language has continued to grow and expand. For better or for worse, features have been added and will continue to be added, should the community find them acceptable.
Java在不断的成长，不断的扩充，然而它在逐渐变化成为一个平台，而不仅仅是一种语言。不知是好还是坏，独具特性的东西一直在不断的添加进来，以后还将会有，社区会接受特性吗？

Some features are not as welcome as others, however. For instance, annotations were a win for the masses -- frameworks like JUnit 4, TestNG, Spring, and Google's Guice grabbed impressive developer mind-share through innovative uses of annotations. Conversely, generics (which were introduced in Java 5) have so far been inconsistently adopted-- at least in their full spirit.
然而，一些特性就没有其他特性那样受欢迎了。举个例子来说，注解就很受欢迎――象JUnit4， TestNG， Spring和Google的Guice这些框架，由于对注解的创新的使用，就得到了不少开发人员的青睐。相反的是，到目前为止，人们对范型（在Java 5中引入）并没有保持对其自始至终的热情。


No closure(s) in sight ...
闭包（Closure）未见踪影

If generics didn't cloud the coding landscape enough, one might find the current discussions surrounding the proposed addition of closures and local functions into Java 7 foggy indeed. While I certainly won't argue their usefulness as constructs, adding them to the Java language syntax could obviate their usefulness by increasing conceptual entropy.
如果范型不足以使编程的前景变的灰暗，有人可能会发现当前围绕关于在Java 7 foggy中加入闭包和局部函数提议的争论。虽然我绝不会否认它们是有用的组成部分，只是，将它们增加到Java语言的语义中，概念的复杂性增加只会降低它们的有用性。

For example, in a prototype reference implementation of closures, one can find the following code, which defines a simple closure supporting Integer addition:
例如，在一个闭包的典型参考实现中，找到如下代码，它定义了一个简单的支持整数加法的闭包：

{Integer,Integer=>Integer} plus1 = {Integer x, Integer y => x+y};

What's particularly interesting is the verbosity of the statement due to Java's innate syntactical requirements -- one could easily rewrite the same functionality in Groovy, for example, as
非常有趣的是，由于Java天生的对语义要求，语句变的拖沓冗余――用Groovy来重写同样功能，却很容易。例如

plus1 = { x, y -> x+y }

Note that the dearth of types arguably makes human parsing of the code's intent easier in the Groovy example. Of course, Ruby's version would be as terse too.
注意到，在Groovy的例子中，类型的缺失无疑使得代码的意图一目了然。当然，Ruby版本也会同样简明扼要。

It's clear that outside forces, such as the popularity of dynamic languages (which already include closures) are influencing Java. You don't have to wait for native closures in Java 7 if you want to use them, though -- both Groovy and JRuby support them quite nicely.
显然，象动态语言普遍受到欢迎此类的外部力量在不断地影响Java。如果想使用闭包，你完全不必等待Java自带的闭包――Groovy和JRuby对其的支持就已经很优雅。


True concurrency
真正的并发

Something else to look forward to with Java 7 is the release of the java.util.concurrent packages, which aim to address true concurrency for Java applications by leveraging underlying hardware. While Java has always supported threading, hardware assets continue to become more robust through a greater emphasis on parallelism; consequently, the Java language is growing to meet these demands.
Java7值得期待的其他事情是java.util.concurrent包的发布，这个包致力于通过充分利用底层硬件来达到真正的并发。虽然Java已经支持多线程，但是通过对并行性的进一步重视，硬件资源将变的越来越健壮。最终，Java语言也发展的可以应付这些要求。

Led by the JSR 166 Expert Group, Java 7 will most likely include a few new features including a fine-grained parallel computation framework dubbed join-fork. The good news is that it appears these features are new classes (and APIs) and are not syntactical in nature.
由JSR 166专家组领导的Java 7将很有可能包含一些新特性，包括名为join-fork的细粒度的并行计算框架。好消息是，看起来这些新特性是崭新的类（和API），与生俱来就不符合句法规则。

The race to RIA
奔向RIA

Rich Internet Applications continued to generate lots of interest among Java Web application developers last year, especially after Sun unveiled JavaFX at JavaOne 2007. The JavaFX product family currently consists of JavaFX Script and JavaFX Mobile.
去年，特别是Sun在2007年JavaOne上让JavaFx对公众面世后，RIA（Rich Internet Application）继续让Java Web应用程序开发人员产生莫大的兴趣，。JavaFX产品家族现在由JavaFX Script和JavaFX Mobile组成。


Reaction to JavaFX appears mixed given the ubiquity of JavaScript for developing Ajax-like applications. It has also been suggested that JavaFX Mobile could widen rifts in an already fragmented mobile environment. All told, many in the community found the JavaFX announcement rushed, and some question whether it is vaporware. Nevertheless, Sun's entrance into the RIA space surely signals a long-term strategy, which further secures Java's future.
由于开发类Ajax应用的JavaScript无处不在，对JavaFx的反应显得见仁见智。看起来JavaFX将会加剧本来就已经四分五裂的移动环境之间的裂缝。很多人感觉JavaFX的公告有点操之过急，还有一些人怀疑它究竟是不是一个雾件。不管怎样，Sun进入RIA领域传达了一个长期战略的消息，这会使Java的前景更加光明。


In conclusion
结语

An African proverb states that Tomorrow belongs to the people who prepare for it today. Thus, the future of Java (at least for the next year) has already been brewing for some time. The events of 2008 will largely be shaped by the JVM itself, as languages like JRuby and Groovy grow in popularity and eventually gain enterprise-wide adoption. The promise of using Java to develop consumer mobile applications also seems more accessible than it has for some time, given Google's foray with Android and Sun's with JavaFX Mobile. Most of us will also be concerned with leveraging the emerging multicore systems and looking to Java 7's java.util.concurrent packages for answers. Lastly, open source Java and the business model surrounding it will continue to grow.
有句非洲谚语说“明天属于那些今天为它准备的人”。因此，Java的未来（至少来年）已经孕育了一段时间了。2008年的大事的很大部分将不仅由JVM本身促成，而且也会随着JRuby和Groovy不断受欢迎，最终得到更多厂商的采纳而形成。由于Google Android的出击和Sun JavaFX Mobile的发布，使用Java开发用户移动应用的前景也好像比以前更加容易到达了。大部分人的注意力将被多核系统的出现吸引过去，期待Java 7 java.util.concurrent包对其的回应。最后，围绕它的开源的Java和商业模型也会不断的成长。

Acknowledgments
致谢

I'd like to thank the following individuals whose valuable insights regarding all things Java helped shaped this article: Neal Ford, Andres Almiray, Dan Allen, Ted Neward, Scott Stirling, Scott Moore, John Smart, Nate Schutta, Michael Nyika, Venkat Subramaniam, Guillaume Laforge, Scott Delap, Paul Duvall, Yvonne, David Pinkham, Rod Coffin, Andrew Binstock, Ken Brooks, Jay Zimmerman, Paul Julius, Tom Copeland, Navjeet Chabbewal, Jason Rudolph, Chris Judd, Dave Aronson, Cliff Berg, David Bock, and finally Alex Ruiz. Thank you all for answering my questions!
我真心感谢以下的个人，是他们关于Java的真知灼见促成了本文：Neal Ford, Andres Almiray, Dan Allen, Ted Neward, Scott Stirling, Scott Moore, John Smart, Nate Schutta, Michael Nyika, Venkat Subramaniam, Guillaume Laforge, Scott Delap, Paul Duvall, Yvonne, David Pinkham, Rod Coffin, Andrew Binstock, Ken Brooks, Jay Zimmerman, Paul Julius, Tom Copeland, Navjeet Chabbewal, Jason Rudolph, Chris Judd, Dave Aronson, Cliff Berg, David Bock, 最后还有Alex Ruiz。非常感谢你们回答了我的问题。


Author Bio
Andrew Glover is president of Stelligent Incorporated, a consulting firm that helps development teams accelerate software development. He blogs regularly at thediscoblog.com and testearly.com.

作者简介
Andrew Glover是Stelligent Incorporated的总裁，Stelligent Incorporated是一家帮助开发团队加速软件开发的咨询公司。他的blog通常是thediscoblog.com and testearly.com。



Resources

• "Scripting on the Java platform" (Gregor Roth, JavaWorld, November 2007) introduces the when and how of using scripts in your Java applications, with examples based on Groovy, Jython, and JRuby.
• "JRuby on Rails: The power of Java, the simplicity of Rails" (Joshua Fox, JavaWorld, February 2007) explains why JRuby may be a better RoR development choice than Ruby.
• "Multicore processing for client-side Java applications" (Kirill Grouchnikov, JavaWorld, September 2007) offers an overview of the multicore processing challenge, as well as a client-side solution based on the new concurrency utilities.
• The Multi-Language VM is an OpenJDK project aimed at prototyping JVM features that will support languages other than Java.
• "Your plastic pal who's fun to be with" (Simon Morris's blog, December 2007) is a quick foray into developing on the Android platform.
• See "Sun to acquire MySQL for US$1 billion" (Jeremy Kirk, IDG News Service, January 2008) to learn more about Sun's expansion in the open source database market.
• Also see Network World's IT Buyer's Guides: Side-by-side comparison of hundreds of products in over 70 categories.
JavaWorld podcasts
• Find out what's so great about Groovy on your way to work, by listening to the JavaWorld podcast interview with AboutGroovy editor Scott Davis (JavaWorld's Java Technology Insider, November 2007).
• You can learn more about what's so great about JRuby by listening to Andrew Glover's podcast interview with Neal Ford (JavaWorld's Java Technology Insider, November 2007).
• In another podcast interview in the same series, No Fluff Just Stuff creator Jay Zimmerman shares his thoughts about smart migrations for 2008 (JavaWorld's Java Technology Insider, January 2008).


资源

• "Scripting on the Java platform" (Gregor Roth, JavaWorld, November 2007) 介绍了在Java应用中何时以及怎样使用脚本，附有基于Groovy，JPython，JRuby的例子。
• "JRuby on Rails: The power of Java, the simplicity of Rails" (Joshua Fox, JavaWorld, February 2007) 解释了在RoR开发者，JRuby可能是一个比Ruby更好的选择。
• "Multicore processing for client-side Java applications" (Kirill Grouchnikov, JavaWorld, September 2007)提供了多核处理挑战的纵览，以及基于崭新的多并发工具的客户端解决方案。
• Multi-Language VM 是一个开源JDK项目，旨在 “以JVM特性为原型，高效地支持除Java之外的语言”
• "Your plastic pal who's fun to be with" (Simon Morris's blog, December 2007) 在Androi平台上开发的一个开创性尝试
• 查看 "Sun to acquire MySQL for US$1 billion" (Jeremy Kirk, IDG News Service, January 2008)以获悉Sun在开源数据库市场扩张的更多讯息。
• Network World's IT Buyer's Guides:  超过70个种类，数以百计产品的对比。
JavaWorld播客
• 听听JavaWorld播客对AboutGroovy editor Scott Davis(JavaWorld's Java Technology Insider, November 2007)的采访，了解了解Groovy对你的工作的高明之处。
• 听听Andrew Glover的podcast interview with Neal Ford (JavaWorld's Java Technology Insider, November 2007)，你可以知道JRuby有什么高明之处。
• 在同系列的另外一个播客采访中，No Fluff Just Stuff的创始人Jay Zimmerman分享了他的关于smart migrations for 2008 (JavaWorld's Java Technology Insider, January 2008)的想法

评论

1 楼 ginge 2008-03-29  

鉴于本人水平有限，翻译过程中存在错漏之处请大家指出，以免造成误导，谢谢。