Tech Watch

Java / j2ee News

Oracle Will Change Solaris and Java

Oracle is expected to change the Solaris operating system it acquired from Sun Microsystems from free and open source to a licensed product.

www.topix.net | 7/30/10 11:23 AM
InfoQ: Oracle Fixes Eclipse's Java Problem
As reported last week, Oracle reacted swiftly to the issues involving the rebranding of the Java 6u21 update. Since then, Oracle have re-spun the Java install, and for Windows machines, the released build is now 1.6.0_21-b07. Oracle should be commended for reacting to, and solving, the problem so quickly. By Alex Blewitt www.infoq.com | 7/30/10 10:30 AM
OpenXava 4m5

OpenXava is a framework to develop AJAX JavaEE/J2EE applications rapidly and easily.

www.topix.net | 7/30/10 9:13 AM
JVM Summit'10

The JVM Summit'10 is finished ! As last year and the year before it was fun, amazing and mind blowing to discuss and share ideas with brilliant people of the Java & JVM community.

www.topix.net | 7/30/10 4:59 AM
Planet Eclipse: Dariusz Luksza: EGit Synchornize ChnageSet – discussion

About 48 hours ago I was describing my first small step to get ChangeSet implemented. Two days is a lots of time, and current status of this feature can be described by this screen shot:

As you can see, the „Git Change Set” appears next to the standard change set representation, this can be changed using third tool bar button (from left hand side).

Currently list of commits contains only commits between base and destination rev, the common ancestor isn’t included or even dispatched by the change set implementation (this can, or even should, be changed). Also there should be included proper graphical representations for commits, folders and files; additionally compare view should be launched when we double click on file. That things should be improved/fixed before I’ll publish code.

Beside that small issues I think that right now it is the best time to start discussion how we (yes, me and you!) would like to use this feature and have it should behave and and look. What you can see in above screen shot is only my proposition and (as always) I’m open for any suggestions and ideas. The best place for this discussion is Eclispe’s Bugzilla and bug 318473, and I encourage you to share yours opinion with us!

I’m looking forward for any feedback about this feature

BTW. One of thins that I’m proud of, in current implementation, is that I haven’t use any kind of internal API of Team Framework ;>

luksza.org | 7/30/10 2:17 AM
Securing the Java Core

Frameworks that provide security features significantly reduce -- although not eliminate -- application developer's burden Rohit Sethi is Director of Professional Services at Security Compass .

www.topix.net | 7/30/10 12:49 AM
Planet Eclipse: Erwin Tenhumberg: Configuration Fix for 1090 Error - SAP Spend Performance Management
Error 1090 Troubleshooting Tips for Spend Performance Management.
weblogs.sdn.sap.com | 7/30/10 12:34 AM
Configuring Hibernate for a Java Servlet Application

Most enterprise applications have to interact heavily with their back-end databases.

www.topix.net | 7/29/10 9:50 PM
The Java EE 6 Tutorial: Basic Concepts, Fourth Edition

Starting with expert guidance on developing presentation layers with Web tier technologies, including JavaServer Faces and Facelets, it also covers building Web services with JAX-WS, RESTful Web Services with JAX-RS and Jersey, developing business logic with Enterprise Beans, accessing databases via the Java Persistence API, and Java EE Security, ...

www.topix.net | 7/29/10 7:50 PM
The Aquarium: GlassFish Patches now at Oracle Support

SunSolve was, and still is, Sun's way of distributing patches; the equivalent mechanism at Oracle is My Oracle Support (MOS), and Gerry just announced thatSun patches now available there. This includes the GlassFish commercial patches like 128640-20, which is one of the patches in GlassFish 2.1.1 patch 6.

I just looked directly for the patch ID (using Sun's patch number), I'll try to dig more info on how to use MOS and will post it later on.

blogs.sun.com | 7/29/10 6:47 PM
Java.net Weblogs: JVM Summit'10

jvmsummit

The JVM Summit'10 is finished !

As last year and the year before it was fun, amazing and mind blowing to discuss and share ideas with brilliant people of the Java & JVM community.

If you want a fast forward glimpse of the state of the JVM languages future presentations are available on the wiki:
http://wiki.jvmlangsummit.com/Main_Page

 

cheers,
Rémi

Attachment Size
800px-Rose-iphone-IMG_0023.jpg46.11 KB
www.java.net | 7/29/10 5:16 PM
Planet Eclipse: Jeff, Paul & Simon: Chapter 20 errata

Page 348 — The steps in section 20.3.1 suggest that you should use the Target Platform Export wizard to get the base set of bundles against which you can build your system. It turns out that that wizard is only available in Eclipse 3.6 (Helios) and later. To date we have been unable to back port that function to Eclipse 3.5.2 (Galileo).  To work around this, you can either

  • Start a plain Eclipse 3.6 on your OSGi and Equinox samples workspace, export the target as described and then switch back to using Eclipse 3.5.2 with the Samples Manager installed
  • Install the Samples Manager into Eclipse 3.6 and work from there.

Note that if you choose the latter approach there may be some minor issues as the book samples and workflows have been tested most rigorously with Eclipse 3.5.2.

equinoxosgi.org | 7/29/10 4:54 PM
Indexing and Searching on a Hadoop Distributed File System

Kashyap Santoki works for Infosys Technologies Limited and can be contacted at KashyapChimanlal_S@infosys.com In today's information-saturated world, the huge growth of geographically distributed data necessitates a system that facilitates fast parsing for the retrieval of meaningful results.

www.topix.net | 7/29/10 3:50 PM
InfoQ: Leverage Points: places to intervene in a system
A key decision for software architects involves where and how to introduce change into a system in order to effect a desired change. Leverage points are those places where micro changes can result in macro results. Twelve categories of leverage point are identified along with concerns about the changes. By Dave West www.infoq.com | 7/29/10 2:56 PM
Planet Eclipse: Denis Roy: Winner of the WTF/loc award

To gauge the quality of code, we’ve all seen the metric called WTF/minute.

I’m inventing a new metric, called the WTF/loc, based on this very short snippet of code.

#!/usr/bin/perl
use strict;
my $cmd = "perl " . shift;

my $h = <STDIN>;
while ($_ = <STDIN>) {
        open (S, "| $cmd");
        print S $h;
        print S;
        for (2..1000) {
                last unless $_ = <>;
                print S;
        }
}

A few comments to explain what’s going on would have made this snippet of code much more maintainable.

dev.eclipse.org | 7/29/10 2:20 PM
Planet Eclipse: Ian Skerrett: Oracle Demostrates Great Community Support and Fixes Eclipse

Every once in a while I am reminded of the lunacy of the Internet, especially headline writers.  On Monday of this week, Oracle released an update to the Java 1.6 update 21 that fixes a problem in a previous version that broke Eclipse.   All the details can be found in the bug or Neil’s good summary.  The good news is that Eclipse is no longer broken!!

The irony however is that the issue just yesterday shows up on Ed Burnette’s ZDNet blog ‘Oracle Rebrands Java, breaks Eclipse‘ and the pillar of all Internet lunacy, slashdot Oracle Java Company Change Beaks Eclipse .   Credit to Ed for actually reporting and testing the fix.  However, the slashdot posting is the following:

crabel writes “In Java 1.6.0_21, the company field was changed from ‘Sun Microsystems, Inc’ to ‘Oracle.’ Apparently not the best idea, because some applicationsdepend on that field to identify the virtual machine. All Eclipse versions since 3.3 (released 2007) until and including the recent Helios release (2010) have been reported to crash with an OutOfMemoryError due to this change. This is particularly funny since the update is deployed through automatic update and suddenly applications cease to work.

No mention the problem has been fixed and wrong on the fact the update was deployed through automatic update; update 21 hadn’t been pushed out yet via automatic update.  Of course the typical slashdot comment ensued, granted some of the comments do point out the reality.  However, as with anything on slashdot, people repeat the headline “Oracle’s Java Company Change Breaks Eclipse” on things like twitter, so the meme continues.  Let me be clear, the problem is fixed:  Oracle Demonstrates Great Community Support and Fixes Eclipse

Eric has already praised Oracle’s response to the situation.  I would like to add my thanks to Oracle for quickly resolving the issue.  I spoke to Oracle about the issue and I can tell you they had already decided to fix it before I spoke with them.  Oracle should be applauded for their response to the bug.  This type of bug could have easily lead to lots of finger pointing but Oracle just did the right thing for the community.  THANK YOU


ianskerrett.wordpress.com | 7/29/10 1:44 PM
Which Notes client do you use?

Ed comments here : I'm definitely inclined to abandon the basic configuration in the next major feature release.

www.topix.net | 7/29/10 11:36 AM
Planet Eclipse: Eclipse Riena: SWT/Qt as alpha download

We are proud to make the first development version of the SWT/Qt platform available.

If you want to follow the progress of the code donation to the Eclipse Foundation you can track these bugs, CQ (link) and dicussion (link).

Please keep in mind this is a development version. All the core  and custom widgets should work.  However, it is not feature complete  and it may be slow. Some things that are missing or incomplete are: StyledText, drag and drop, browser support, program start (launch external programs).

We provide binary bundles for the following OS:

  • Windows 32bit, XP and above
  • Linux 64bit
  • Mac OSX 32bit

We tested it with the following eclipse packages (Galileo SR2):

You need the SWT bundle (download) and one of the platform specific bundles (includes Qt):

For installation, simply replace the SWT bundles in your “eclipse/plugin/” folder with the ones you downloaded from us.

Due to a bug you have to start eclipse with the “-noSplash” parameter:
% eclipse -noSplash

To test the styling capabilities, and we are sure you want to, download the AdvancedStyler plugin (download) and place it in your “eclipse/dropins/” folder (restart required). It will help you playing with the amazing Qt styling. We included some examples for an easy start.

For more information look at the Qt Style Sheet documentation found here.

To launch the AdvanedStyler  hit the little paint icon  in the toolbar and a dialog will pop up where you can change the styling on the fly.

The AdvancedStyler dialog looks like this

Hitting “Reset” brings you back the default style. “Update” applies the current style to your SWT application.

We would  like to know what you are thinking, so please leave a comment. We are also very interessted in how you would use the new possibilities to style an application. So please feel free to post or send us screenshots.

Happy styling …

www.compeople.eu | 7/29/10 9:41 AM
Planet Eclipse: Neil Bartlett: The Eclipse/Java 6u21 Blame Game

Ed Burnette published an informative article on ZDNet about the recent incompatibility problem with Eclipse and Java 6 update 21. Unfortunately the comments contain a lot of nasty accusations and finger-pointing, with people variously blaming Oracle or Eclipse or both for the mess… and even Ed’s article title seems a trifle unfair on Oracle.

To address those who accuse Eclipse of inappropriately using an internal variable, consider for a moment why this was done. Here are the facts:

  1. The Sun JVM as shipped does not allow enough PermGen memory for a large application such as Eclipse to run. Incidentally many server applications also need more PermGen than is available by default.
  2. There is no standard option to expand the PermGen. The option on the Sun JVM is -XX:MaxPermSize but the “XX” part indicates this option is specific only to the Sun JVM and is not available on other JVMs such as JRockit, IBM J9 etc. In fact using it with those JVMs can cause them to simply emit an error and exit.
  3. Therefore Eclipse needs to detect whether it is on the Sun JVM specifically before it adds the -XX:MaxPermSize option. This cannot be done in Java because by the time the JVM has started it is too late, so it has to be done in the native launcher executable, i.e. eclipse.exe, which is coded in C. At this point the Java system properties are not yet available, but the properties in the exe/dll file are visible.

So I don’t think Eclipse has done anything particularly wrong here. Neither has Oracle, there was no reasonable way for them to know that a simple rebranding would cause such a problem, and they responded very quickly to fix it.

Of course the fix is only a temporary one, as Oracle are going to want to change that variable eventually. So rather than pointing fingers, perhaps the Java community could try to come up with a real long-term solution. Such as a way to manage the JVM’s memory from within the JVM… or getting rid of the cursed PermGen altogether?

njbartlett.github.com | 7/29/10 8:00 AM
Open Source javasnoop hacks Java? #BlackHatUSA

From the ' Caffeinated Tools ' files: LAS VEGAS. Security researcher Arshan Dabirsjaghi now has a new tool out that will enable users to 'hack' Java.

www.topix.net | 7/29/10 7:27 AM
Planet Eclipse: David Green: Testing REST Web Services with JPA and Spring

REST Web Services can be particularly difficult to test, with the need for networking, a web container, multiple threads and transaction management creating extra complexity beyond your standard unit test. In this article I demonstrate patterns designed to address this complexity while enabling complete testing of your REST web service stack.

The ideal web service unit test will use the same principles discussed in my previous article:

  1. clean database with mocked data so that we can reliably test specific scenarios
  2. rollback to avoid side-effects after our test
  3. in-memory database so that no environment setup is required

In addition, we’ll need to run a web container for our unit test. To maintain a zero-setup test environment, we’ll have our unit test start a web container for the purpose of running our web service. By having each test start and stop the web container, tests become very simple to run and we’re guaranteed that our tests will have a clean environment with no external dependencies.

Web Container

Normally starting a web container is difficult to do in a unit test, and container startup time can be a problem — however with the right choice of web container we can overcome these problems. Winstone is a small, fast web container that is designed to be embedded in Java programs. By using Winstone, we’ll be able to start and stop the web container as part of our unit test setup and tear-down with relative ease.

Starting Winstone is as simple as this:

 Map args = new HashMap();
 args.put("webroot", pathToWebRoot);
 args.put("httpPort", String.valueOf(port));
 Launcher.initLogger(args);

 // start winstone
 winstoneLauncher = new Launcher(args);

Winstone only takes a couple of seconds to start up. Shutting it down is as simple as this:

 if (winstoneLauncher.isRunning()) {
  winstoneLauncher.shutdown();
 }

To hide the details of winstone from our unit tests, we can create a class WebApplicationContainer, which is responsible for starting choosing a port, starting/stopping Winstone, and providing a base URL for our tests:

public class WebApplicationContainer {

 private static final Random random = new Random(System.currentTimeMillis());

 private Launcher winstoneLauncher;

 private File webRoot;

 private int port;
 
 /**
  * start the webserver, guarantees that the webserver is started upon return.
  * @see #stop()
  */
 @SuppressWarnings({ "unchecked", "rawtypes" })
 public void start() {
  if (winstoneLauncher != null) {
   throw new IllegalStateException("already started");
  }
  port = findAvailablePort();
  
  
  Logger log = Logger.getLogger(WebApplicationContainer.class.getName());
  log.fine("Starting web container on "+getBaseUrl());
  
  Map args = new HashMap();
  try {
   args.put("ajp13Port", "-1");
   args.put("useJasper", "false");
   args.put("webroot", webRoot.getAbsolutePath());
   args.put("httpPort", String.valueOf(port));
   Launcher.initLogger(args);

   // start winstone
   winstoneLauncher = new Launcher(args);

   // wait for Winstone to finish starting up
   // we do that by attempting to connect via socket
   final int maxRetries = 150;
   for (int x = 0; x < maxRetries; ++x) {
    if (testForSuccessfulStartup()) {
     break;
    }
    if (x == maxRetries - 1) {
     throw new IllegalStateException(
      String.format("Connection to localhost:%s failed."+
       "  Did the web container start up successfully?"));
    }
    // wait and then try again
    Thread.sleep(100L);
   }
   Logger.getLogger(WebApplicationContainer.class.getName()).
    info("Started web container at "+getBaseUrl());
  } catch (Exception e) {
   throw new IllegalStateException(e);
  }
 }

 private int findAvailablePort() {
  ...
 }
 
 private boolean testForSuccessfulStartup() {
  // test to see if the web container is listening on the address/port combo
  try {
   Socket socket = SocketFactory.getDefault().createSocket("localhost", port);
   socket.close();
   return true;
  } catch (UnknownHostException e) {
   throw new IllegalStateException(e);
  } catch (IOException e) {
   return false;
  }
 }

 /**
  * stop the web container
  * @see #start()
  */
 public void stop() {
  if (winstoneLauncher == null) {
   throw new IllegalStateException();
  }
  
  winstoneLauncher.shutdown();
  winstoneLauncher = null;
 }

 public String getBaseUrl() {
  return String.format("http://localhost:%s/", port);
 }
 ...
}

REST Service Unit Test

A complete test for our web service ends up looking like this:

@RunWith(SpringJUnit4ClassRunner.class)
@Transactional
public class BlogServiceClientTest extends BlogServiceTest {
 @Autowired
 private BlogServiceClient blogServiceClient;

 @Autowired
 private WebApplicationContainer webContainer;

 @Before
 public void before() {
  webContainer.setWebRoot(computeWebRoot());
  webContainer.start();

  blogServiceClient.setBaseUrl(webContainer.getBaseUrl()+"api");
  // use the client instead of the service directly
  service = blogServiceClient;
 }

 @After
 public void after() {
  if (webContainer.isStarted()) {
   webContainer.stop();
  }
 }
}

You might be thinking "where are the @Test methods?". The beauty of our web service test is that it extends our service test: all of the test methods we were running before using direct method calls are now also run over our web service protocol. By using inheritance, other than setup of our web service there’s nothing else to do. In other words, our service tests are run twice: once using Java method calls, and again over-the-wire using our web service. This ensures that we see consistent behaviour in both modes of execution.

BlogServiceClient is an implementation of BlogService (our service interface under test) based on Spring’s RestTemplate. It’s a REST client for our service, implementing the same Java interface as our server-side service. This enables us to substitute the REST client service implementation in our test.

Transaction Management and JPA

Now that we’re able to start our web service and run tests we’re done, right? Not quite: we still need to manage transactions and our test data. This is somewhat more complicated with our web service: recall that we want our unit test to have the following qualities:

  • clean database on startup
  • run in a transaction that rolls back after the test
  • mocks all of its own data

Employing the techniques we’ve already established in Patterns for Better Unit Testing with JPA helps, but is not quite enough.

Our service implementation is running in a web container. The web container services incoming HTTP requests with threads in a thread pool. Our service is pretty much guaranteed to be running on a distinct thread, not the same thread as that running our unit test method. As a result our service bean will be running in it’s own transaction context. There are two problems that arise from this:

  • our service won’t be able to see the data we’ve mocked up in our test
  • our service method will commit its transaction

Both of these things are undesirable. To overcome this problem we’ll apply a little trickery: we’ll provide an entity manager that is shared by both the test thread and the web container thread servicing our HTTP requests, and we’ll prevent any commit or rollback from occurring on that entity manager while it’s in use in a unit test. We do this by wrapping the entity manager factory in our test environment:

<bean class="greensopinion.restexample.test.jpa.TestEntityManagerFactory" 
 id="blogDomain">
 <property name="delegate">
  <bean
   class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
   <property name="dataSource" ref="dataSource" />
   <property name="persistenceXmlLocation" 
    value="classpath*:/persistence-test.xml"/>
  </bean>
 </property>
</bean>

Our TestEntityManagerFactory employs the standard delegate pattern, with the exception that it changes the default behaviour of createEntityManager():

 public EntityManager createEntityManager() {
  if (theEntityManager == null) {
   theEntityManager = delegate.createEntityManager();
  }
  return new TestEntityManager(theEntityManager);
 }

It creates and returns a singleton entity manager instance. This allows us to share a single entity manager between our unit test and the web container. We also wrap the entity manager so that we can control it’s lifecycle (we prevent close()) and that of it’s transaction (we prevent commit() and rollback()).

While we know that the EntityManager is not thread safe, it’s okay to share it between threads providing that no two threads access it at the same time. Since our REST client will block on any calls to the server, we’re not at risk of concurrent access.

Source Code

Complete, working source code demonstrating these patterns and others is available on GitHub:

http://github.com/dgreen99/greensopinion.restexample

The source contains two Eclipse projects: one for the web application, and one for unit tests. The unit tests all run and pass, and the web application can be started and deployed with a MySQL database.

Service Patterns

The service is split into the following:

  • Service interface – defines the service contract
  • Service bean – implements the service over JPA
  • Service controller – exposes the service using Spring REST
  • Service client – implements client end of the REST service, used in our tests

This gives us a good separation of concerns, and client code need not always know if it’s calling an in-process or out-of-process service.

JPA domain objects are exposed by the service interface. This helps in a few ways:

  • The service is usable in other parts of the application that deal with the domain
  • It helps to reduce the amount of code that must be written

However it has drawbacks:

  • It exposes the design of our domain, limiting our ability to change it in the future
  • Changes to the domain may inadvertently break the service interface for third-party clients
  • The service controller must be careful to expose shallow copies of our domain objects

This approach may be feasible for some projects. It’s common to see transfer objects as well, which allows a service to be explicit about it’s data model without exposing the domain implementation details.

Missing Functionality

Notably this sample code is missing two crucial aspects of a normal web application:

  1. Exception handling should be built-in to our service controller so that errors can be propagated gracefully.
  2. Data validation is not performed by the service bean.

These aspects of the sample application are left unimplemented.

Summary

Testing REST web services can be easy by following the following patterns:

  • implement a web service client to exercise your service from unit tests
  • run the web service in your tests with a lightweight embedded web container
  • share the entity manager and transaction context between the service and test

By applying these straight-forward techniques it’s possible to overcome the complexity inherent in testing a web service, enabling better coverage and higher quality applications.

References

Technologies used in this project:

greensopinion.blogspot.com | 7/29/10 6:26 AM
The Aquarium: GlassFish at FISL

Alexis and Arun went to FISL11 at Porto Alegre (Wikipedia, GeoMap) and have provided reports including photos; see Alexis' Back from FISL, and Arun's AFISL 2010 Trip Report.

Alexis's slides are available via SlideShare: GlassFish OSGi - from modular runtime to hybrid applications and The future of the GlassFish community.  Arun's presentation was all demos, which he has also made available as a YouTube playlist.

Open Source is very strong in Brazil (see for example this post). As you can see from our GeoMap, GlassFish has a fair amount of adoption, but we need to improve our outreach. If you have suggestions or want to contribute, post them as comments on this entry, or contact us at theaquarium at sun dot com.

blogs.sun.com | 7/29/10 5:40 AM
The NetBeans E-commerce Tutorial - Integrating Transactional Business Logic

The purpose of this tutorial unit is to demonstrate how you can use the object-relational mapping capabilities provided by EJB and JPA technologies to gather data from a web request and write to a back-end database.

www.topix.net | 7/29/10 4:27 AM
InfoQ: The Role of the Enterprise Architect
Although the enterprise architect has become one of the more popular and sometimes respected profession in IT, the discussion about the enterprise architect’s role continues. A round table discussion at The Open Group’s Security Practitioners Conference attempted to clarify the enterprise architect’s role. By Boris Lublinsky www.infoq.com | 7/29/10 3:19 AM
QA#4: Java EE 6: Developers focus on business logic, Much lower TCO - by Johan Vos

In the Java EE 6 Feedback from Community series you can learn about how Java EE 6 is currently being used in production, development and deployment environments used within the community, and even feature requests for Java EE 7. This entry comes from Johan Vos who started to work with Java in 1995.

www.topix.net | 7/29/10 12:17 AM
Planet Eclipse: Lars Vogel: Eclipse 4.0 Application Platform – Tutorial Updated

As you know the Eclipse 4.0 SDK is out.

It also appears in discussions that some people don’t think Eclipse e4 is a good idea.

Other people seem to like it.

To help you to decide yourself I updated my Eclipse e4 Tutorial to Eclipse 4.0 Application Platform – Tutorial.

Together with Tom Schindls Tutorial you should be able to have a good start with Eclipse 4.0 SDK.

Please remember that the target of the core e4 Project is to improve the programming model of Eclipse and to provide an improved way of influencing the UI. The standard plugins are still the same and behave the same way.

My Tutorial also needs improvements, unfortunately it is not as far and deep as I like, but I hope that is will give you a good start. If you find issues, problems with my tutorial please let me know. The “more to come” section of my tutorial lists my future plans.

 
www.vogella.de | 7/28/10 11:25 PM
DevX - Java: Adobe Buys Day Software to Bolster ECM Portfolio
Adobe Systems shelled out $240 million to acquire Day Software Holding, a Swiss developer of enterprise content management software. www.devx.com | 7/28/10 11:18 PM
Down

Learn how to download and install a Ubuntu image and then go through some basic shell commands to help you navigate through the Linux environment.

www.topix.net | 7/28/10 11:12 PM
Java.net Weblogs: QA#4: Java EE 6: Developers focus on business logic, Much lower TCO - by Johan Vos

Content available at: http://blogs.sun.com/arungupta/entry/qa_4_java_ee_6

www.java.net | 7/28/10 10:43 PM
Planet Eclipse: Wayne Beaton: Eclipse is… a Community

Summer madness has force me to leave a gap in the delivery of my award-winning “Eclipse is…” blog series. But I’m back now. In this series, I walk through the many different aspects of Eclipse, starting with the definition that most people are comfortable with: Eclipse is a Java IDE. But, as the series discusses, Eclipse is more than that. Technology-wise, Eclipse is a platform for building IDEs, tools, applications, runtimes, and more. Eclipse is open source projects. Lots and lots of open source projects covering a vast array of topics from modeling to identity management and object-relational persistence.

It’s certainly true that great technology is an important part of what makes Eclipse what it is. However, technology alone isn’t enough. Technology needs to have a community. And at Eclipse, we’ve got community. At Eclipse, we bring the community together to do great things.

Community is about coming together to do things as a group that no single person can do by themselves. Whether it be chasing snakes from a local watering hole, or building great technology and support.

Eclipse is actually a collection of communities that intersect. The Eclipse Development Process defines three different communities: users, adopters, and contributors/committers. Each of these communities has different requirements and expectations from Eclipse.

The first community, users, tends to regard of Eclipse primarily as a consumable product. They are primarily concerned with using an Eclipse-based IDE to build solutions. We estimate the size of this community to be between four and six million in size; though the fact that more than a million downloads of the new Helios packages occurred in the first month of availability leads me to believe that the community is even larger than our estimate.

The adopter community contains individuals and organizations that build solutions based on Eclipse technology. This can be as simple as providing a plug-in that runs in an Eclipse IDE, or as involved as basing an entire product on the Eclipse Rich Client Platform (RCP) or Rich Ajax Platform (RAP). It also includes those individuals and organizations who base a business on providing development assistance and support for Eclipse technology. One way or another, adopters tend to be building Eclipse plug-ins to provide solutions that directly or indirectly leverage Eclipse technology (though this is not necessarily the case as some Eclipse technology–like EclipseLink, and EMF–can be leveraged in plain-old-Java application). We don’t even try to estimate the size of the adopter community; it’s just too hard to do. There are more than a thousand “solutions” in the Eclipse Marketplace. This is really just the tip of the iceberg; it doesn’t include, for example, the bajillions of in-house applications (some of these are captured in case studies) that leverage Eclipse technology.

The contributor/committer community contains that group of individuals and organizations who contribute directly to Eclipse projects. These are the individuals who provide patches and/or contribute new functionality to the various Eclipse projects. Contributors tend to participate directly in an Eclipse project by providing code, ideas, answers to questions in the forums, and more. Committers are a subset of the contributors with write access to the resources maintained by a project (committer access is provided on a project-by-project basis). The idea is that over time, a contributor is invited to become a committer and elected into that position based on credibility established over a period of time. At last count we had almost a thousand committers and thousands of contributors (more than 11,000 individuals have contributed at least one patch to an Eclipse project).

Developing a community is an important part of being an Eclipse project. In fact, an integral part of the Eclipse Development Process. As part of a review process, a project is required to demonstrate their community-building activities, like blogging, speaking opportunities and more.

The graphic on this slide attempts to show that the various communities interact with each other. Users consume the software produced by the contributors/committers and the adopters, and provide feedback. Some subset of those users will provide feedback and other input into the project. Adopters also provide feedback and input. Some number of adopters may become contributors and ultimately committers. Projects with large communities have greater potential to have very diverse committer communities and broad consumption by adopters. There’s really more to it, but I’ll leave this discussion for a later post.

At this point in my presentation, I usually stop and ask the audience how many of them already have Eclipse Bugzilla accounts. Then, noticing that a large number of people haven’t put up their hands, I facetiously marvel that so many people have managed to use Eclipse for so long without ever having encountered any sort of problem. I use this opportunity to tell people that it’s okay to open bug reports (I once tried to use Erich Gamma’s bug-reports-are-like-love-letters analogy but decided that that wasn’t my style).

So, Eclipse is a community. A big community. A growing community. A diverse community. More than a community, though, Eclipse is… an Eco-System.

On a side note… committers: get your talk proposals for Eclipse Summit Europe in today!

dev.eclipse.org | 7/28/10 9:36 PM
Planet Eclipse: Boris Bokowski: Eclipse 4.0 Overview
Since I don't have enough energy left to also write a thousand words, here is just an overview picture of the Eclipse SDK 4.0 Early Adopter Release that we shipped today. I hope you find it useful.
borisoneclipse.blogspot.com | 7/28/10 8:47 PM
Planet Eclipse: Eclipse Announcements: Eclipse SDK 4.0 Now Available for Early Adopters
The Eclipse Foundation is pleased to announce the availability of Eclipse SDK 4.0 , the next generation Eclipse platform. Eclipse has a very large and successful ecosystem of plugin providers and RCP application developers. Eclipse 4.0 introduces new features that make it easier for the members of the ecosystem to build and assemble Eclipse plugins and RCP applications. feedproxy.google.com | 7/28/10 8:44 PM
Planet Eclipse: Ian Skerrett: Eclipse SDK 4.0: The Journey of a New Platform

Today is a very exciting and important day for the Eclipse community.  The Eclipse Platform project has released Eclipse SDK 4.0, the next generation of the Eclipse platform.  For technical perspective on the release I point you to Mike Wilson’s excellentt blog post ‘Growing the future’.

Congratulations to the entire Eclipse 4.0 team for shipping the release (which of course was on schedule )!  It has been a long journey to get to this day.  What started out as a ‘blue sky’ BOF at EclipseCon 2007, followed by some more concrete ideas at EclipseCon 2008, the details began to emerge via a series of summits and communitydiscussions.  It has been a great community effort.

Not everyone will agree with the decisions, ideas or architecture of Eclipse 4.0.  That is to be expected in a healthy community with lots of passionate participants.   It is a credit to the team that they have made the tough decisions and ‘shipped the code’.

The journey is far from complete.  The next step is to get Eclipse Foundation projects and Eclipse plugins to migrate to Eclipse 4.0.   This is why we have named Eclipse 4.0 an ‘early adopter release’.  Over the next number of months I am hoping every Eclipse project will migrate their code based to the new platform.  There is binary compatibility so it should be a straight forward process.  It is great to see some people have already started.

At this time, we don’t expect Eclipse IDE users or even companies to ship products based on Eclipse 4.0.  These groups tend to rely on a number of different Eclipse projects/plugins that will need to migrate to the 4.0 platform.  In 2011, I would expect the Indigo release train will include an end user release based on Eclipse 4.x.

Congratulations again to the e4 team for shipping Eclipse 4.0.  Now it is up to the rest of the community to continue the journey towards the Eclipse 4.0 platform.  Make sure you tell us your stories as you begin the process.


ianskerrett.wordpress.com | 7/28/10 8:07 PM
Planet Eclipse: Tom Schindl: Eclipse 4.0 and tutorial on writing e4-RCP-application released

The Release

The e4-Team just announced the availability of the Eclipse 4.0 SDK “Early Adopter Release” (Reviewslides) which marks a major platform update since the inception of 3.0 6 years ago.

Just to reiterate what the 4.0 SDK is and to set expectations right. The 4.0 SDK is marked as an “Early adopter release” targeted at Plug-in Developers who want to test their code on the upcoming 4.x platform and report problems because of broken APIs or “APIs” not available anymore because they used internals of the platform.

The 4.0 SDK “Early Adopter Release” is not targeted for use as your Primary IDE so keep this rough edges in mind when giving the 4.0 SDK a try.

When takeing a closer look to the release you’ll notice that in reality multiple different things have been released:

  • Eclipse 4.0:
    • Eclipse 4.0 Application Platform: The new application platform to write OSGi-base (UI-)Applications centered around a new programming model using DI and a modeled application kernel
    • Eclipse 4.0 Compatible Rich Client Platform: Compability layer for API clean 3.x bundles to run unmodified on the new Application Platform
    • Eclipse 4.0 SDK: Eclipse 4.0 Application Platform + Eclipse 4.0 Compatible Rich Client Platform + PDE 3.6 + JDT 3.6
  • Eclipse 4.0 Technologies (also called “e4 SDK 0.10″ / “e4 release July 2010″ because the releasing project is e4):
    • XWT + Tooling: XAML for SWT/JFace and Visual Designer Tools
    • Semantic Filesystem implementation
    • Application Modeltooling

A small hint for Plug-in developers who are trying to debug their Plug-In by launching an inner Eclipse and all Eclipse 4.0 Application-Developers. The Eclipse 4.0 SDK misses at the moment the source bundles for the new Eclipse 4.0 components and you need to install it through the p2-repositories pre configured for you.

We recommend to install:

  • EMF SDK
  • Modeled Workbench Source
  • CSS Support Source

to successfully step through the code using the debugger.

My personal main focus in the Eclipse 4.0 development for the last 2 years has been the “Eclipse 4.0 Application Platform” whose goal is to modernize and simplify the development of OSGi-based UI-Application using DI and a modeled application approach. In the last few months I also worked on a tool to make writing applications for the Eclipse 4.0 Application Platform easier.

The model tooling

Since March I’ve been dedicated half of my 4.0 development time implementing support for the application model underpinning the Eclipse 4.0 Application Platform.

The model tooling has not yet graduated out of the e4-incubator and so is not part of the Eclipse 4.0 SDK download and you’ll have to install it using the preconfigured e4-repository – you find it in the “E4 Tools”-category.

The tooling is working in 2 modes:

  • Design/Development-Time mode: This is the standard mode you are using when developing an application. In this mode you operate on a Application-Model persisted as a XMI-File in your workspace.
  • Live mode: In this mode you are operating on the live model of a running application and are able to inspect and modify live

The Eclipse 4.0 Modeltooling is written to run native on the Eclipse 4.0 Application Platform (no useage of the Backward-Compat-Layer) but also integrates smoothly in the Eclipse 4.0 SDK.

Probably one of the most remarkable things though is that it runs also in a 3.6 SDK enabled by the so called Forward Compat Layer I started developing who does the opposite of the backward-compat-layer. It allows you to run components using the Eclipse 4.0 Progamming model which is built upon POJOs and DI in a 3.6 environment.

This makes it possible to write Eclipse 4.0 Applications using the 3.6 SDK as the screenshot demonstrates:

All you need is to install the tools using the e4 Update Site which is available on http://download.eclipse.org/e4/updates/2010.

The tutorial

When introducing new technologies we know that it is important to give people a medium sized example application which explains the concepts of the framework and provides them “monkey see, monkey do” example code. That’s why I’ve worked in the last few days/weeks on a tutorial which helps people getting started writing applications using the “Eclipse 4.0 Application Platform”

You can download the tutorial which is released under Creative Commons Attribution-NonCommercial-ShareAlike 3.0 using this link. The sources codes are released under EDL-1.0/EPL-1.0 and are available from github and/or as individual zips (urls found in the PDF).

If you only want to take a look at an application built using the Eclipse 4.0 Application Platform you can downloaded using the links below:

You need Java 6 to run the demo although Eclipse 4.0 itself only needs Java5. To get accounts displayed on the left you should enter the following values in the Preference Dialog:

  • Username: john
  • Password: doe
  • Host: blabla.com

It looks like the update-code triggering of the AccountView is a bit weak so if you are not informed about the opening of the session after clicking around stop and starting the application should help you (I’ll try to work on a solution in the days to come).

Just in case you like the service I’m providing to you for free with this tutorial and you want to donate some cents here’s the button to push:


tomsondev.bestsolution.at | 7/28/10 8:01 PM
Planet Eclipse: Eclipse Announcements: Attend Eclipse Testing Day in Darmstadt
Bredex, MicroDoc and the Eclipse Foundation are pleased to announce Eclipse Testing Day in Darmstadt , which takes place September 8, 2010. Eclipse Testing Day is a day-long event for technical developers, testers, architects and managers to learn more about testing with Eclipse and OSGi technology. feedproxy.google.com | 7/28/10 7:17 PM
Review: Free Java application performance monitors

July 28, 2010, 10:00 AM - InfoWorld - The code is polished, the site map is frozen, and the UI is dripping with gorgeous colors.

www.topix.net | 7/28/10 6:52 PM
Planet Eclipse: Mike Wilson: Growing the future

Last year, at about this time, I wrote a lengthy, omnibus post called Eclipse has a future. It’s purpose was to capture some of the challenges that are facing the Eclipse community, and describe how the work that we were doing in the e4 Incubator Project could help to address them. Since then, our investment in that work has continued to grow, and we are now ready to ship a new version of the Eclipse SDK, built with technology that has graduated from the incubator, called the Eclipse SDK 4.0 Early Adopter Release.

I’m going to talk about what it is about Eclipse 4 that makes it interesting and important, but first I wanted to say a bit about why we grew the tagline “Early Adopter Release”.

An Early Adopter Release

As I noted last year, the Eclipse Project developers have known for quite a while that we were going to have to innovate in some significant ways in order for the base platform to continue to be compelling in the face of changing pressures in the industry — notably, a range of new technologies for building desktop apps (e.g. AIR, Silverlight, etc.) and the push towards using the web to deliver “desktop grade” applications. At the same time, however, many of our consumers were looking for the strongest possible backwards compatibility / stability so that they could continue to move forward with the release train without needing to invest in responding to changes in our layer (or any other one they depended on, for that matter).

In addition, we had begun to feel that the complexity of the platform code itself was preventing us from growing our community. More than ten years of development had left the code in a brittle state where almost any significant change would break more places than it fixed, making it extremely difficult for new developers to get involved.

The result of this was a conscious splitting of our focus into an ongoing development stream, Eclipse 3.x, where we could continue to offer the strongest possible backwards compatibility and stability, and a brand new project, the e4 Incubator, where we could work on the kinds of major innovations and code transformations that we believed were necessary. As the work in this incubator matured, it would move outward to the most appropriate place: some to other projects at Eclipse.org, some to our Eclipse 3.x SDK (as the flexible resources work did in 3.6), and some to a new “forward looking” Eclipse 4.x SDK, which would “organically” become the focus of Eclipse based development as it proved its worth.

So here we are in 2010. We’ve gone from a prototype — last years “0.9″ release that used significant chunks of old code as “shims” to get things running — to a real Eclipse SDK built on some powerful new underlying technology. The thing is though, this really is new technology. It’s not like we went in and tweaked the implementation a bit; we actually gutted the workbench implementation and started again.

The good news is that it seems like our bet has paid off. If you look at the pace at which the new version of the workbench has come together, it’s obvious that this code is much easier to work with. Personally, I’d say we’ve seen about a milestone’s worth of improvement each week for the last month or so. Over all, the Eclipse SDK 4.0 is completely usable for development. The team has been running on it exclusively for at least a month, and the drive to eat-your-own-dog-food has gone from a painful experience to one that feels just like working with Eclipse 3.x (except that it looks nicer ).

The thing about dog-fooding though, is that it works through the scenarios that are most important for the people working on the code, and basically nothing else. It’s great at getting something we can use, but not so good at covering all of the myriad ways that the community has built on top of us, which gets me back to why we’re calling this an “Early Adopter Release”.

We need your help.

To get from the current state to something that is solid, bug free, and complete enough to be included in a release train (or used to ship product) is going to take your input. We need to know where the changes we’ve made impact you and your uses of Eclipse. We need to know whether there are things that are missing that you must have. We need to know if there have been performance impacts… Basically, we’re asking you to invest enough time to take the Eclipse 4.0 release and load your plug-ins and projects on top of it, and then tell us what is working and what isn’t. And, in case that wasn’t enough, we’re asking you to continue to work with us over the course of this year, re-trying milestone builds and helping us verify that we’re converging to where we need to be.

Now, I wish I could tell you that it would be immediately obvious how this was going to benefit your work. I think there are some very compelling things about the new workbench, but I honestly can’t tell how important they’ll be to you. Really, I’m asking for your help here because I really do believe that this is the future of Eclipse, and I know that it will be great with your help, or it will die on the vine without it.

The one thing I can offer in return is an absolute commitment to be responsive to your input. Our goal is to have every milestone on the road to 4.1 be a “mini-release”; one that is visibly more complete, more capable and more solid than the ones before it. To do this, we will be strongly focused on the issues that you report to us — to the early adopter goes the spoils (er… bug fixes).

What’s there now

If you’re looking for the full list of what’s new in Eclipse 4 you should check out the New and Noteworthy. I’m not going to reiterate all that, but I would like to talk a bit about some of the technological pieces that have graduated from the e4 Incubator, which are the basis for this “newness”.

For example, the most immediately visible change you see when you start up Eclipse 4 is the new look and feel:

    Eclipse 4.0 look and feel

This is a great, fresh new look with a modern style and excellent use of whitespace to reduce visual clutter. But, in addition to being some best-of-breed design work [no, I didn't have anything to do with it] this also represents the first time where the appearance of the workbench — everything from the background colour of the main toolbar to the radius of the curve on the folder tabs — is controlled by CSS.

Why we believe this is important, is that it simultaneously gives people building RCP apps and products based on the SDK much more control over the look (i.e. the “branding”) while making the “language” of that control be one that makes sense to designers (i.e. instead of requiring them to know the internals of our Presentation API. Ugh!). It also opens up opportunities for people building apps that contain embedded HTML content to share more of their design resources.

Just as an example, here is an ugly, but definitely um… different look we rolled using only CSS changes:

    A deliberately ugly look made by hacking the CSS

The underlying SWT changes to support this work were done by the SWT team as part of 3.6 development (with a couple of tweaks since then). The CSS Engine itself was contributed by Angelo Zerr, with ongoing development from several others. To see an example of how you can use this new support in an RCP app, to excellent effect, take a look at Kai Tödter’s Contacts Demo.

Also, if you are interested in pushing the limits of what you can do with the CSS support, please come talk to us. There are definitely places where we would like to provide even more flexibility, and we know the workflows around editing the CSS could use work. Knowing what would be most valuable to the community here would be excellent.

Despite being less immediately visible, the most critical change in Eclipse 4 is the switch to a modelled user interface.

Essentially, the entire structure of the application’s user-interface is represented as an EMF model. This model has been carefully tuned so that it has strong separation between unrelated concerns, and is layered so that Eclipse 4 based applications can incrementally take only those pieces they actually need. This is a significant advance over the “take everything and prune out the bits you don’t need” approach used in Eclipse 3.x (and earlier) RCP applications. What this actually means is that people building new Eclipse 4 based applications do not have to include any of the scaffolding that is specific to the workbench’s use of the model, nor do they have to include any of the code that supports backwards compatibility for 3.x apps, if they don’t need it. We believe this new way to work is sufficiently important that we have christened it the “Eclipse 4 Application Platform”.

Note that this does not imply that you must give up 3.x compatibility in order to build RCP applications in 4.x. We continue to be committed to supporting full API compatibility between 3.x and 4.x, so building Eclipse 4 based, traditional RCP applications is still supported. It’s just that once developers start using the Eclipse 4 Application Platform, the benefits will be obvious.

At the workbench level, the flexibility we get from the use of the modelled user interface, together with another piece of technology newly graduated from the incubator, hierarchical contexts, also opens up brand new capabilities for 3.x compatible applications. In this case, by separating the application code from the context in which it is running, we can remove many of the artificial constraints imposed by the 3.x workbench. Dependency injection is used to provide the application code with the values it needs without requiring it to know where they came from, and in turn, the 3.x compatibility support makes use of this to ensure that all traditional change notification, data binding, etc. behaves as expected.

You know, reading that last paragraph, it’s clear that this is a case where a picture would definitely be worth the proverbial thousand words. Here is an example of a common workflow for us on Eclipse 4.0 that would be simply impossible to do in 3.x:

    Console in the editor area

What you are seeing here is the completely unmodified 3.x Console view being displayed in the same stack as the editors. We like this because it’s a great way to give views like the Console more screen real-estate, but every 3.x user will tell you “You can’t put views in the editor area(!)”.

Really, this is about making the decisions relating to where views and editors show up (for example) a matter of policy rather than being hardwired into the implementation. Because, in 4.0, these policy “add ons” can be done by simply controlling what transforms are possible on the model, the code to implement them is very easy to write, is typically all held in a single class, and can be changed to support the needs of your particular application. For anyone who understands what the equivalent code in 3.x looks like, this is one of the clearest pieces of evidence we have that the new modelled UI is much easier to work with.

Where we go next

Before I go on, I have to say I’m absolutely humbled by how much effort everyone has put in to get us to where we are today. From the “old school” platform committers, to the new ones we gained because their work graduated from the incubator (Brian de Alwis, Kai Tödter, Yves Yang), to all those who continue to work on cool new technology in e4, to the many who have helped us with the design, and the many more who tested (with special thanks to Stefan Mücke), commented, documented… All of you have my greatest respect. I hope you all know we have built something great here, and we ought to be proud of it.

The thing is though, we also know one other important thing: We’re not done.

And we’re not done in an at least three significant ways:

1) plugging the holes

You don’t have to look far when playing with Eclipse 4.0 SDK Early Adopter Release to find places where there are bugs and things that are just outright missing. I’d apologize about this, but the truth is we got as far as we needed to so that our “early adopters” can help to guide us the rest of the way.

We have bugzilla for the bugs and a wiki page that captures the most obvious missing features. We know that there’s lots more work to do, and we’re going to do it.

2) graduating more

Even though we did see some important new capabilities graduate from the incubator, there is lots more work being done there that hasn’t graduated yet. We know that’s the natural order of an incubator — things will graduate when they’re ready — but what’s important is that we continue to push to make the level of investment it takes for that work to reach maturity.

As an example, for those who’ve been following e4 since the beginning, one of the most obvious missing pieces in Eclipse 4.0 is the Eclipse Application Services (a.k.a. “the 20 things”). Fundamentally, we still believe the EAS are going to be important for the future of Eclipse; particularly if we want to start looking at building plug-ins in languages other than Java. We did make some progress on this, this year, but we didn’t get even close to far enough for it to graduate as part of the 4.0 release. I’m disappointed, but I know we won’t let this one go. Stay tuned for more in the weeks ahead.

3) continuing to innovate

So listen, let’s say you’ve got this great idea about the next big innovation that we need, and that you are looking for just the perfect place to make it happen. Well, have I got an incubator for you!

Seriously, the e4 Incubator is intended to be a place to experiment, push the boundaries, whatever-it-takes on an ongoing basis. Just because Eclipse 4.x has started doesn’t mean its one burst of innovation is over. If you have an idea for something new, please come talk to us.

I was very happy to see that Olivier suggested bringing a JDT related project into e4 on improving support for Java-like languages. I think that’s a great idea, and I hope he can get enough critical mass to get it going. If you’re interested in that possibility check out the discussion on jdt-dev.

Anyway, even for me, this has been a marathon post. I hope that it helps to give you an idea of what we’ve been up to. Please give Eclipse SDK 4.0 Early Adopter Release a try, and tell us about your experiences.

Peace,
McQ.

dev.eclipse.org | 7/28/10 6:42 PM
Java.net Weblogs: Oracle Video Challenge: an Opportunity to Attend JavaOne for Free!

The Oracle Video Challenge, which started yesterday and runs through August 9, will provide three winning contestants with a free Oracle OpenWorld or JavaOne and Oracle Develop full conference pass. In addition, everyone who submits a "valid" video will receive a $400+ registration discount.

Here's a brief overview:

Test your power of persuasion. Grab your video camera, and convince your peers why you deserve to go to Oracle OpenWorld, JavaOne or Oracle Develop for FREE. The community will pick the top five finalists in each category (Oracle OpenWorld, JavaOne, and Oracle Develop), and a panel of Oracle judges will pick the final three winners (one for each category). Having trouble thinking of what to say? Tell your peers what session, track, or event you can’t miss out on. Explain how much Oracle OpenWorld, JavaOne, or Oracle Develop will help further your career and/or development skills.

*EXTRA Bonus* - Everyone who submits a valid video entry will get a discount code for Early Bird pricing to use at time of registration for Oracle OpenWorld or JavaOne and Oracle Develop. This is a savings of $400 or more over the onsite price!

Get the complete details at the Oracle Video Challenge site.

Subscriptions and Archives: You can subscribe to this blog using the java.net Editor's Blog Feed. You can also subscribe to the Java Today RSS feed and the java.net blogs feed. You can find historical archives of what has appeared the front page of java.net in the java.net home page archive.

-- Kevin Farnham
Twitter: @kevin_farnham

www.java.net | 7/28/10 5:19 PM
Planet Eclipse: Eric Rizzo: Tip of the hat to Oracle
As most Eclipse community members probably already know, a recent change by Oracle in the JDK/JRE for Windows caused serious problems for Eclipse. But in a sign that Oracle really does understand the importance of Eclipse in the Java community, as well as a nice gesture of cooperation and consideration, they've rolled back the change that caused the problems and released new builds .
I admire Oracle's willingness to respond quickly to this issue, in spite of the fact that Eclipse code was admittedly relying on non-documented and non-API data. Ian Skerret also deserves credit for directly engaging people at Oracle to make this happen.

Hats off to cooperation!
bewarethepenguin.blogspot.com | 7/28/10 4:14 PM
Oracle rebrands Java, breaks Eclipse

Earlier this month, Oracle released a new version of Java, 1.6.0_21 . Unfortunately as Eclipse users quickly discovered, it was incompatible with Eclipse and Eclipse Rich Client Platform programs.

www.topix.net | 7/28/10 2:48 PM
Java.net Weblogs: FISL 2010 Trip Report

Content available at: http://blogs.sun.com/arungupta/entry/fisl_2011_trip_report

www.java.net | 7/28/10 2:06 PM
Planet Eclipse: Marcel Gorri: Post #11 – More than Strings – 28 Jul, 2010 – 10h00 (GMT-3)

Software localization is the process of converting or preparing a computer program to be suited for a particular region. Localization can sometimes be simply a matter of language translation, but it can also prove to be a much more complex process when it comes to issues such as formatting, currency, date and time, sorting patterns, imperial versus metric standards and so on.

Since Sequoyah already provides a localization framework for strings, and with the goal of providing a more complete and easy to use framework, Sequoyah now intends to deal with other localizable resources besides strings.

In this document we have a proposal of such effort, where we list some user stories describing how we intend to extend the current framework to deal with images, sounds and video in a first moment. In a later moment, the framework will also be capable of treating even other localizable resources, such as formatting, currency, date and time.

If you have any comments or suggestions about this proposal, please contact us through our mailing list.

(Posted by Marcel Gorri)


sequoyahproject.wordpress.com | 7/28/10 2:04 PM
Ed Burnette: Oracle rebrands Java, breaks Eclipse

Earlier this month, Oracle released a new version of Java, 1.6.0_21 (also called 6u21). Unfortunately as Eclipse users quickly discovered, it was incompatible with Eclipse and Eclipse Rich Client Platform (RCP) programs.

Bug 319514 in the Eclipse bug database has all the gory details, but in a nutshell, Oracle changed the company name property on java.exe from “Sun Microsystems, Inc” to “Oracle”. The change was not announced or documented in the release notes. Ironically, Eclipse has been using this value since 2007 to work around another Java problem where Sun’s default for the “MaxPermSize” option was too small for Eclipse to run. When it changed, the workaround no longer worked, and many people encountered “PermGen” errors when they started Eclipse.

Oracle responded by respinning 6u21 on Monday to restore the value, but warned that it will be changed for good in JDK 7. A company developer wrote:

As part of Oracle’s rebranding of Sun’s products, the Company Name property of the java.exe file, the executable file containing Oracle’s JRE for Windows, was updated from “Sun Microsystems” to “Oracle” in Java SE 6u21.

After the updated JRE was posted on java.sun.com, it was reported that the change affected Eclipse users on Windows by causing it to hang when starting Eclipse after updating to the rebranded JRE. A workaround was quickly identified and posted on Eclipse’s website, but a wide distribution of the rebranded JRE executable could negatively impact many Eclipse users.
In consideration to Eclipse and other potentially affected users, Oracle has restored the Windows Company Name property value to “Sun Microsystems”. This value will be changed to “Oracle” in JDK 7.

The change affected only the Windows version of the JRE, not the versions for Solaris and Linux. To accommodate this update the Windows build version will increase from 6u21-b06 to 6u21-b07. Solaris and Linux distributions will continue to ship build 6u21-b06.

An engineering side note: The “Java” property values for java.vendor and java.vm.vendor were never changed in the jdk6 releases and will remain “Sun Microsystems, Inc.”. It was understood that changing the vendor property values could impact applications and we purposely did not disturb these vendor properties. The Windows specific exe/dll file “COMPANY” value is what is at issue here, not the Java properties. It came as a surprise to us that anyone would be inspecting or depending on the value of this very platform specific field. Regardless, we will restore the COMPANY field in the jdk6 releases. Note that the jdk7 releases will eventually be changing to Oracle, including the java.vendor and java.vm.vendor properties.

This morning I verified that the official Oracle download site has been updated with the correct version and that it works with Eclipse. Here’s what it prints when I run java -version:

C:\> java -version
java version “1.6.0_21″
Java(TM) SE Runtime Environment (build 1.6.0_21-b07)
Java HotSpot(TM) 64-Bit Server VM (build 17.0-b17, mixed mode)

If you downloaded Java for Windows 32-bit or 64-bit recently, be sure you have the 1.6.0_21-b07 version and not b06.

www.zdnet.com | 7/28/10 1:58 PM
Testare 0.1

Testare is an open source testing framework that aims to simplify the test development process for distributed Java applications.

www.topix.net | 7/28/10 1:53 PM
NaviSite Uses Oracle's Sun Servers for Managed Services Offering
NaviSite, Inc., a provider of complex hosting, application management and managed cloud services for the enterprise market, is using a combination of Oracle's Sun servers and Oracle software to run its mission-critical systems. With more than 1,500 customers in 10 datacenters across the US and UK, NaviSite needed to expand its virtualization platform to meet the growing infrastructure demands of its customers, while delivering industry-leading performance and availability.

read more

java.sys-con.com | 7/28/10 11:00 AM
Speakers & Sessions At IndicThreads Cloud Computing Conference, India


IndicThreads.com International Conference On Cloud Computing will be held on 20-,21 August in Pune, India. The conference aims to demystify cloud computing & discuss migrating & implementing cloud solutions The conference sessions deal with topics like Amazon EC2, Microsoft Azure, JavaEE 6 on the cloud, Cloud Security & Privacy, Google App Engine, Cloud Data Migration, SaaS, [...]
www.indicthreads.com | 7/28/10 10:26 AM