Thoughts on Eclipse RCP Training

April 5, 2009

At EclipseCon I had the opportunity to sit down with Wayne Beaton and record a podcast on Eclipse RCP training. It’s really not a sales pitch kind of thing, more of a discussion of the challenges faced by developers new to RCP.

But after we finished recording, it occurred to me that I’ve never really expressed what I feel the value of Eclipse RCP training is. It’s common for developers to approach me and say “I know I need RCP training, but how do I justify this to my manager?” Well for those of you in this situation, here is what I would say.

Time is money

The first argument is a purely financial one. It’s just a fact that acquiring knowledge takes time and effort. If you spend days or weeks at your desk assembling information on RCP from websites, articles and books, then your salary during this time is the cost of knowledge. The question is, how does this approach compare with learning from an instructor?

According to many of my students, learning RCP in a classroom is much more effective. There are a variety of reasons for this, which I’ll get to in a minute. But it seems to be true for most people that training significantly shortens the RCP learning curve. I’ve taught many classes over the past few years, and based on student feedback I’d say that RCP training often pays for itself in weeks, not months.

RCP is hard to learn

One of the main reasons RCP training is so effective is that the subject area is complicated. Unlike other technologies, RCP is not standards-based, so there is no canonical spec you can go to for answers. To be honest, RCP is less a coherent framework than an aggregation of related technologies (SWT, JFace, OSGi, Eclipse Platform).

The problem for someone learning RCP is where to start and how to acquire knowledge in a coherent and orderly way. What RCP training does (if it’s done well) is to cut through the noise and present a clear vision of what RCP is and how to use it.

Getting a team up to speed

Oftentimes RCP is introduced to a team by a self-taught lead developer who evangelizes the technology. When the decision is made to use RCP, the lead developer is often called upon to share his knowledge with the rest of the team.

The problem is that most developers are not (and do not want to be) teachers. Creating carefully designed presentations and labs is difficult. Communicating the information clearly to students with a variety of backgrounds and learning styles is even more difficult.

The real magic to being a good teacher is to remember what it was like to not know something. This might sound like a zen koan, but it’s really just another way of describing empathy. If you find a good trainer, I think you’ll be impressed by what this magic can accomplish.

Why can’t I just read a book?

This is a really good question. It’s obviously true that some people can learn RCP by reading books. That’s how I learned. But a better question is could you learn more effectively through a training course?

I’d argue that a training courses is more effective than books for a number of reason. First, students have a variety of learning styles. Some learn by hearing, some by seeing, some by doing, most from a combination of all of these. Only a training course can communicate information in all of these ways. Second, a multi-day training course appears to function something like immersion-learning for a foreign language. While people usually read books a bit at a time, there is a distinct advantage to focusing all or your mental energy on a subject for 3-4 days straight.

Speaking empirically, I’ve had more than a few students tell me that they’ve read books but that things didn’t click until they took the course. Whatever this click is, it appears to be what students need to get started working productively with RCP.


Making sense of e4

March 30, 2009

There was so much going on at EclipseCon last week that I have to admit my head is still spinning. I’m trying to get back to work, but my mind keeps turning to the people I met and the sessions I attended.

One area I really wanted to get into at EclipseCon was e4, which is the project that is attempting to redefine the Eclipse platform. The work being done is varied and fascinating, and I’ve been trying to figure out what it all means at a high-level. Well from what I’ve learned so far, the two main focuses of e4 are flexibility and simplicity.


The platform is becoming more flexible in so many ways, it would be hard to list them all. But here are a few examples:

  • Internal structure of workbench window is up to you. Use perspectives or not. Embed parts in other parts, etc.
  • Much stronger styling support using style sheets.
  • Ability to create widgets and parts using different toolkits and even different languages.

One thing is clear – e4 is going to drastically increase our options when developing RCP applications.


The platform is becoming simpler in that the platform framework is being broken down into smaller and more uniform APIs that are loosely coupled to each other. Examples of this are:

  • Increased focus on POJOs throughout the various APIs.
  • Decoupling of APIs through contexts and dependency injection.

I really do think that it will be easier to develop RCP applications after these changes are made. Hopefully it will make my job as an RCP trainer easier too!

The conflict between flexibility and simplicity

“There are two ways of constructing a software design: One way is to make it so simple that there are obviously no deficiencies, and the other way is to make it so complicated that there are no obvious deficiencies. The first method is far more difficult.”

Sir Charles Anthony Richard Hoare

What’s interesting is that flexibility and simplicity are usually in conflict. In framework design, we usually trade flexibility for simplicity and vice-versa. So how will the e4 team pull this off?

The answer lies in the idea of insightful simplicity. There are many types of simplicity, and some are not at all useful to software developers. But insightful simplicity arises when a team has lived with and understands a domain so thoroughly that they start to see the problem space in an entirely new way. Insightful simplicity can result in architectures that are not only simpler but that dramatically increase flexibility, enabling developers to create entirely new types of applications.

Insightful simplicity usually arises only after an initial framework has been created and evolved for an extended period of time. Frameworks tend to expand and get more complex as new use cases are incorporated, but eventually there comes a point when a team starts to see how the entire thing can be collapsed and simplified. This is where we’re at with the Eclipse platform, and the e4 team is now taking this insight and turning it into a reality.

Personally, I can’t wait to see what going to happen when developers get a hold of this technology. It’s going to be amazing!

Real World RCP at EclipseCon

March 10, 2009

In my opinion, one of the best ways to learn about a technology is to listen to people talk about their own projects. Developers who have been in the trenches and worked through the nitty-gritty day-to-day issues have so much to teach us and can save us a lot of time and effort.

If you agree, I hope you’ll consider attending the Real World RCP session at this year’s EclipseCon. If you do attend, you’ll hear 4 developers talk about some extremely interesting RCP usage scenarios, including earthquake damage simulation and nuclear plant testing. You’ll also hear about how RCP can be combined with a variety of other technologies, including CNF, EMF, and GEF to solve real-world problems.

So stop by Wednesday morning! If you’re currently working with RCP or evaluating it for a future project, I think this session will be worth your time.

Video and Eclipse

March 3, 2009

For an upcoming project I need to be able to show Flash videos inside of an RCP application. Java has never been known for its multimedia functionality so I didn’t have very high hopes.

Fortunately, with Java Media Components things seem to be moving in the right direction. JMC is an API that allows you to play media files using the video functionality of the underlying operating system (there is work being done to provide cross-platform codecs along with the API, but it’s unclear how extensive this will be). JMC is distributed as part of the JavaFX platform, but it can function independently inside of a regular Swing application.

Using this recent article as a guide, I managed to create an Eclipse plug-in that contributes a very rudimentary video player view to Eclipse or any other RCP application. If you’d like to try it yourself, click here for the source code (exported project). Note that the current code only works on Windows.

Video playing inside the Eclipse IDE

Above you can see a Flash video of Wipeout playing inside of my Eclipse IDE. Wipeout is my 5-year old daughter’s favorite show (if people are falling down, she’s laughing), so after 20 years as a software developer I’ve finally written some code she’d be interested in!

One thing to note is that JMC relies on the codecs installed on your machine. There have been some complaints that JMC is not finding or utilizing the codecs most people have installed, and hopefully this situation will improve. If you find that you’re getting MediaUnsupportedException errors when opening files, you may want to install a codec pack. The CCCP pack seems to work for most people.

Adding the Progress View to your RCP application

February 16, 2009

Last week Prakash G.R. wrote an excellent post on Using progress bars. This is definitely a post that I’ll be referring my students to in the future. There is still one missing piece to the progress bar puzzle, though, and that is how to add the Progress View itself to your application.

You might think that this view would appear on its own when requested through the UI, and in my opinion this is the way things should be (this has been discussed in past Bugzilla entries). For instance, your users may see a job running in the status bar of your RCP application, like this:


When the user clicks on the conveyor belt icon, they would expect to see a detailed progress view allowing them to cancel the job, like this:


So how do you get this working? The answer is not what you might think. Normally, you would add a view by finding the view class and creating a new view extension. But for the Progress View, things are a bit different. The ProgressView class itself is internal and is not intended to be referenced directly. It is exposed, however, through an extension factory. The XML to create the view extension looks like this:

            name="Progress View"

The last piece we need to make this work is the view icon, which can be found in the org.eclipse.ui.ide plug-in (not part of the RCP SDK). The actual file in this plug-in is icons/full/eview16/pview.gif. You’ll need to copy this icon into your own plug-in and reference it in the view extension.

So while not extremely straightforward, it’s not that difficult either. Interestingly, there are a variety of other things you can add to your application through the same extension factory mechanism. If you’d like to find out more, check out the constants in the ExtensionFactory class.

RCP-based Marketcetera featured in the NY Times

January 15, 2009

It’s not every day that an Eclipse Rich Client Platform application is covered in the NY Times. In fact, I can’t remember it ever occurring before.

But yesterday Marketcetera, a developer of RCP-based open-source trading software, was featured in the Bits Blog of the NY Times. Of course there’s no mention of RCP itself, but it’s nice to know that those building tools with this framework are having some success.

Yesterday also marked the 1.0 release of this product, so congratulations to everyone at Marketcetera! I’m sure I speak for everyone in the RCP community when I say we wish you all the best.

Making Music with Eclipse RCP

December 18, 2008

I’m always on the lookout for Eclipse Rich Client Platform applications that push boundaries. RCP is much too often associated with the Eclipse IDE itself, and this leads us to think that RCP applications need to be IDE-like. But there are many more uses to which RCP can be put, and I think we’re still only beginning to scratch the surface.

For example, check out Neck Diagrams (nice web site, by the way!), an RCP application that allows guitarists to create chord boxes and neck diagrams using a visual editor. I’m not much of a musician myself, but this seems like a great tool. What I really like, though, is how this program stretches the idea of what we think of as an “RCP application”.


This is also a great example of software created by a single developer. I love that RCP makes it possible for a solo developer to realize their vision and bring a product to market quickly.


If you’re interested in seeing this software in action, check out the screencast.