Comparing Eclipse and NetBeans RCPs

I recently had the opportunity to see a presentation about NetBeans RCP given by Geertjan Wielenga at AlpesJUG, and to chat with the speaker afterwards. We had an interesting discussion about how NetBeans RCP and Eclipse RCP compare to each other.

Some food for the trolls

DISCLAIMER: Before you start reading this article, I have to tell you that I am an Eclipse fanboy, a contributor on several Eclipse.org projects, developer of an Eclipse RCP app, and have been developing Eclipse plug-ins since I left school. Although I try to be objective in the following article, you may feel it is too Eclipse-oriented. If this is the case, I am sorry...but Eclipse is better ;)

RCP applications are developed exactly the same way with NetBeans or Eclipse

Most of differences between Eclipse RCP and NetBeans RCP development are just in terminology. In NetBeans we speak of modules, in Eclipse, of plugins; we use the NetBeans Platform instead of Equinox, we have Matisse instead of Window Builder. We also have an extension registry with extension points on both platforms, to contribute extensions, and an RCP application is a set of provided modules/plugins + some of your own extensions.

It is the same thing; we can develop them the same way with either Netbeans or Eclipse.

Eclipse RCP vs NetBeans RCP starts with... SWT vs Swing

When getting started with RCP development, here is the main thing encountered, and this is technically the main difference between both Platforms: Netbeans uses Swing as a widget library, whereas Eclipse uses SWT. In my opinion, that's not a big difference, but when it comes to choosing between Netbeans and Eclipse, there is a bigger impact when you start a new application or migrate a legacy one. People will probably choose the product with their favorite widget API.

This is the main technical difference, but it is really minor. In my opinion, this difference is not important enough to make a distinction.  Let's look deeper, to see what these solutions provide as extensions and so on.

NetBeans is not an OSGi platform, but...

It provides exactly the same necessary features as what is used when developing Eclipse RCP plugins. MANIFEST has different keywords, but there are still modules (or plugins in Eclipse terminology) with their own classloaders and so on.

Additionally, there are a lot of integrations with OSGi. The NetBeans platform can run along with an OSGi container, and it can handle OSGi Bundles. For RCP development, the NetBeans platform provides all the necessary OSGi stuff RCP developers use. During his presentation, Geertjan highlighted some NetBeans OSGi integration by starting Netbeans over Equinox and loading EMF bundles in NetBeans.

NetBeans has an publisher, Eclipse has an ecosystem

That's probabably one of the key arguments in the debate, and it has a very strong influence on both products. The entire NetBeans roadmap is piloted by Oracle which is wholly responsible for it. At Eclipse, there is no such single pilot. The Eclipse Fundation oversees Eclipse development, but there is not ONE single publisher, there are lots of contributors from different companies. Eclipse is not only modular technically, it is also modular in term of organization. There are several projects that are developed by independent groups. There might be some dependencies between them, but in the end, you have different teams developing different projects.

NetBeans is a single project developed by a company, whereas Eclipse is an amalgamation of different projects developed by a community of individuals and companies. Then...

NetBeans is homogeneous, Eclipse is heterogeneous

Eclipse developers must admit this: NetBeans is much more homogeneous than Eclipse. And this is true in several domains: UI, ergonomics, code quality (which by the way is quite good, according to NetBeans users who find it less buggy than Eclipse code). This is a plus for NetBeans since users who know how to do one task with NetBeans will easily figure out how to do another. It is pretty user-friendly, especially for users who are new to the Java IDEs world.  They can easily leverage most of the IDE and the platform; thanks to its high consistency (standardization). Thus NetBeans rapidly becomes straightforward to use and leverage.

Compared to NetBeans, Eclipse seems difficult to fully manipulate. There can be a lot of differences between 2 projects, in term of usability (creating a web project is quite different than creating a plug-in project, as you often need to learn how to do something), and also in term of quality. The Eclipse platform quality is very good, and so are most of the mature projects, but there are some others are more buggy and makes the IDE less comfortable. Also, when you reuse some code from other projects, you often have to tweak it to get it working well. For Eclipse developers like me, that's no big deal; but for new users or for people coming from NetBeans, that can be a major issue.

and...

NetBeans has some tools, Eclipse has a lot of projects

The openness of Eclipse provides something very different from NetBeans. NetBeans is one product with different tools. Eclipse is one platform with different projects. These projects are much more numerous than NetBeans components, and they allow you to take several roads at the same time. Eclipse has a kind of wide usefulness that can handle classic IDE problems, Mobile-Development problems, Model-Driven problems, Rich Internet Application problems, and so on.

Two years ago when it was time to choose a name for the 2010 "Helios" Eclipse release, I especially liked the proposal for Hydra, because it is made of one body and several heads. This is a metaphor that fits Eclipse well. To go further with the Hydra comparison, it is considered to be a monster by many people, though a very powerful one...

Eclipse projects - so many, so powerful

I see in NetBeans something more under control, more cohesive, and less scattered. Great tools are provided with NetBeans (Matisse, Installer Framework, and more) to facilitate the development of RCP apps. Getting started with RCP is probably easier with NetBeans since things are more consistent, but I sense a lack of opportunity to find and reuse some very cool things from other projects - one of the great things you get used to in developing Eclipse RCPs. (I remember how tickled we were to discover and reuse the wiki capabilities of Mylyn.)

If I had to use a mythological metaphor, I think I would compare NetBeans to a Minotaur: a strong and nice-looking beast, but with only a single head ;)

The "simpler" NetBeans: good-looking isn't everything