Two days ago was the Helios DemoCamp in Darmstadt at Deutsche Telekom.  I think it was a very successful evening with a whole bunch of good talks. Two of them are very noteworthy.

The first one was presented by Marcel Bruch. He talked about the Eclipse Code Recommenders project which he’s working on at TU Darmstadt. The basic idea behind this project is to provide a way to recommend code. He used the analogy of the Amazon online store. When you buy a book you always get a recommendation along the lines of, “People who bought this book also found this one interesting…”. The Code Recommenders does exactly the same just with code.  Watch the great screencast the Code Recommenders Team provides if you don’t want to take my word for it.

Another especially noteworthy demo for me was presented by Stefan Lay. He demo’d the Eclipse Git Team provider called EGit.  In addition to the tooling he presented Gerrit. Gerrit is an automated review tool for Git. The scenario he presented was to push some changes to a remote repository. The changes were caught by gerrit to be reviewed.   With those changes however, an automated build failed and gerrit sent an automated message that the changes couldn’t be applied because they broke the build. I think this will make the workflow much easier for code review and keeping the repository stable. The EGit project already uses Gerrit for their productive work.

To put it all in a nutshell it was a very cool DemoCamp with 120 attendees and nice buffet afterwards. At this point I want to thank Ralph Müller and the Foundation who organized a spontanous Eclipse Stammtisch after the DemoCamp. It was great to talk to all the guys individually. The bad thing about this is that the evening went by too fast. But there also a good thing. Most of those people will also attend the Eclipse Summit Europe in November and we can meet again.

Tags: democamp, eclipseRT, egit, equinox, helios, rap, rcp, swt, talks

I finally had the time to care about one of my outstanding tasks – provide a tutorial and example how to use Equinox Security. While the tutorial was initially targeted for RAP users, I also added a launch config and a target definition for RCP as the code is the same for both runtimes. The tutorial will provide some hints and pointers how to setup your login procedure, like shown below:

After logging in (hint, hint), you’re able to inspect the currently active Subject. I made up this example to be as simple as possible to demonstrate the key concepts of Equinox Security, and not the ones from RAP/RCP.

As I said, you can either choose between RAP as runtime (above) or RCP (below).

In addition to the authentication mechanism, I wrote a pretty simple LoginModule to show how to connect your authentication process to an alternative backend (eg. LDAP, Kerberos, …).

As I put the tutorial into the Eclipse wiki, I encourage everyone to extend the tutorial with hints, tricks or ideas what you can do with Equinox Security. Hope the tutorial helps to get up to speed how to use secure your RCP/RAP applications.

Tags: eclipseRT, equinox, jaas, rap, rcp, security, Single Sourcing

We are very pleased to report that the long awaited 2nd edition of the Eclipse RCP book (http://eclipsercp.org) is going to the presses on Thursday, April 15th. That means it should be in the stores by the end of the month. Of course, you don’t have to wait, you can pre-order from Amazon or read it online at Safari. Check out the book website for more info.

In addition to the snazzy new cover, this book is an update of the original content to include new technologies, updated workflows and more detail. Here is the marketing blurb from the back cover…

In Eclipse Rich Client Platform, Second Edition, three Eclipse Rich Client Platform (RCP) project leaders show how to use Eclipse 3.5 (“Galileo”) to rapidly deliver cross-platform applications with rich, native-feel GUIs.

The authors fully reveal the power of Eclipse as a desktop application development platform; introduce important new improvements in Eclipse 3.5; and walk through developing a full-featured, branded RCP application for Windows, Linux, Mac, and other platforms—including handheld devices and kiosks.

Drawing on their extensive experience, the authors cover building, refining, and refactoring prototypes; customizing user interfaces; adding help and software management features; and building, branding, testing, and shipping finished software. They demonstrate current best practices for developing modular and dynamically extensible systems, using third-party code libraries, packaging applications for diverse environments, and much more.

For Java programmers at all levels of experience, this book

• Introduces important new RCP features such as p2, Commands, and Databinding
• Thoroughly covers key RCP-related technologies such as Equinox, SWT, JFace, and OSGi
• Shows how to effectively brand and customize RCP application look-and-feel
• Walks through user interface testing for RCP applications with SWTBot
• Illuminates key similarities and differences between RCP and conventional plug-in development

Hands-on, pragmatic, and comprehensive, this book offers all the real-world, nontrivial code example working developers need—as well as “deep dives” into key technical areas that are essential to your success.

Tags: book, eclipse, rcp, syndicate

The new EPP packages for Helios M6 are uploaded to the download area and just need some more hours to be distributed to the Eclipse download mirrors until we can make them available for the public from eclipse.org/downloads. The mirroring is important, because otherwise the eclipse.org uplink would be entirely saturated and no one could get the Helios M6 bits in time before EclipseCon.

In the meantime, I’d like to highlight some additions that I recently did as a package maintainer of the RCP package. (If you don’t know what a package maintainer is you should consider joining my talk on Monday about ‘Building EPP packages‘.)

• git is becoming more and more popular at Eclipse and EGit is always one of the first plug-ins that I am installing whenever I unpack a new Eclipse milestone on my computer. The logical step: Include EGit in my RCP package because I think that I am not the only one who needs this tool.
• Another addition that I recently made is the RAP tooling. My daily work has changed and in the last months I am doing more RAP development than RCP development. I am not entirely sure if one needs both in one package, maybe RAP needs to go into its own package, but so far I think both technologies  complement each other. I am happy to get feedback – see bug 230357.
• Last but not least: The Marketplace Client (MPC) is included to allow early feedback – the developers of this nice tool need your feedback to bring it into the best possible shape for Helios!

Now let’s wait until the packages are available… and I need to go back preparing my EclipseCon slides.

Tags: egit, git, helios, rap, rcp

We recently had a workshop on redView with the developers of the project, probably many of you know ekke. We wanted to evaluate it and gain a better understanding if we could use it in the context of a project in the insurance space.

redView looks pretty promising, and although personally I am not a big fan of modeling and code generation there might be a sweet spot for redView for people who have tons of forms to fill in data.

One really nice thing about redView is that they created a detailled install instruction (a yoxos profile could probably help here), and a bunch of demos to get started.

http://redview.wordpress.com/howto/examples
http://redview.wordpress.com/howto/installation/
http://sourceforge.net/projects/redview/files/

P.S: The obligatory question about single sourcing redView has been discussed, and as redView is EMF + Riena it looks feasible to get redViews working in RAP. Even the visual form designer imposes no hurdles that could not be overcome (plain SWT, no GEF).

Tags: modeling, rap, rcp, riena

I enjoy seeing people use EclipseRT technology in the wild. Recently I met and spoke with Austin Riddle from the Texas Center for Applied Technology (TCAT) about how they are using the Eclipse Rich Ajax Platform (RAP) and what applications they are building with it.

1. What does your application(s) do?

We have several live RAP applications that take the form of information dashboards. These dashboards allow decision-makers and analysts to disseminate information and produce a common operating picture related but not limited to global biosurveillance and large-scale emergency preparedness/management. Users can log in to our systems, customize their view of information via component and profile switching, visually integrate information within the dashboard and selectively share information between echelons of human infrastructure. Our US government customers have been very pleased with the power and flexibility of the systems.

2. Why did you choose Eclipse RAP?

We needed a powerful Rich Internet Application. We needed one that had to provide capabilities that frankly push the limits of what a traditional RIA could deliver. It also had to perform on older hardware and software. After working with and analyzing other options, including GWT, Flex, OpenLaszlo and others, we decided that RAP provided both the features we needed to fulfill our requirements, and the framework to develop custom features that empower our users even more. Being able to leverage other Eclipse Runtime Technology in our applications greatly reinforced our decision.

3. How did single sourcing benefit your project?

Our organization has a significant investment in Eclipse RCP capabilities that we needed to leverage in order to meet our dashboard requirements. It was amazing to see elements from our desktop systems just “appear” in our RAP application after just “dropping” the bundles in. Also, during our development process, we actually wrote capabilities in our RAP application that could be used in our desktop RCP applications. This “reverse” single sourcing was a pleasant surprise!

4. In the end, how did RAP help and benefit your project?

Most impressively, we were able to implement a first working prototype of a dashboard system in 30 days! RAP gave us the ability to rapidly prototype and ultimately provide solid systems that have withstood the scrutiny of rigorous government security evaluations. Currently, we are looking into bringing even more of our eclipse-based desktop investments to the web.

Cool stuff, huh?

Tags: case study, eclipseRT, rap, rcp

There has been a lot of talk lately about p2.  While many people know p2 as the update mechanism used by Eclipse, it is in fact a general purpose provisioning platform.  This means you can use the provisioning platform as a base to build a highly customized provisioning solution for your own needs… whether it is an Eclipse application, OSGi application or anything else.

On September 15, I will be presenting an introduction to p2. In particular, I will demonstrate how you can use p2 to build a provisioning solution for Eclipse RCP applications. The webinar will teach you how you can:

• Make use of the p2 provisioning platform for software management
• Integrate the creation of p2 repositories into your build system
• Reuse the p2 user interface and existing work-flows
• Customize the p2 user interface for your specific needs
• Debug common pitfalls

For more information, please see the registration page.

If you want anything else discussed about p2 in the webinar, please leave a comment and if there is time, I will try to get to it.

Tags: p2, rcp, webinar

When adding keybindings to an existing Eclipse RCP application, it is extremelly helpful to get realtime information about which keybinding registered and to what command handlers it is mapped to. Why is that?  Because sometimes the operating system or another widget will consume the keyboard event before it gets to the command framework. Other times there are several handlers bound to the same key causing a conflict.

Enabling Tracing for Keybindigs

Fortunatelly, this information is easy to get, if you enable the right tracing options:

org.eclipse.ui/debug = true
org.eclipse.ui/trace/keyBindings = true
org.eclipse.ui/trace/keyBindings.verbose = true

After that each keystroke will produce some output on the console:

KEYS --- WorkbenchKeyboard.press(potentialKeyStrokes = [CTRL+PAGE_UP, CTRL+])
KEYS --- WorkbenchKeyboard.executeCommand(commandId = 'org.eclipse.riena.navigation.ui.previousSubApplication', parameters = {})

In the above you can see that Ctrl+PageUp is mapped to the ‘previousSubApplication’ command.

Some times there is a conflict – i.e. one keybinding is mapped to two or more ‘active’ command handlers. This looks like this:

BINDINGS --- A conflict occurred for CTRL+SHIFT+W
BINDINGS ---     [Binding(CTRL+SHIFT+W,
	ParameterizedCommand(Command(org.eclipse.ui.file.closeAll,Close All,
		Close all editors,
		Category(org.eclipse.ui.category.file,File,null,true),
		org.eclipse.ui.internal.CloseAllHandler,
		,,true),null),
	org.eclipse.ui.defaultAcceleratorConfiguration,
	org.eclipse.ui.contexts.window,,,system), Binding(CTRL+SHIFT+W,
	ParameterizedCommand(Command(org.eclipse.riena.navigation.ui.closeModuleGroup,Close module group,
		,
		Category(org.eclipse.riena.navigation.ui.swt,Riena Navigation Commands,null,true),
		org.eclipse.riena.internal.navigation.ui.swt.handlers.CloseModuleGroup@39880a,
		,,true),null),
	org.eclipse.ui.defaultAcceleratorConfiguration,
	org.eclipse.ui.contexts.window,,,system)]

What happened here is that Ctrl+Shift+W was already bound to the CloseAllHandler via the ‘file.closeAll’ command. I was not aware of this initially, because it is defined in the org.eclipse.ui plugin. So I accidentally bound another command and handler to Ctrl+Shift+W. With the output I quickly realized what was going on. I ditched my own command and instead made ‘CloseModuleGroup’ a handler for the ‘file.closeAll’ command.

Tags: bindings, eclipse ui, jface, rcp, tips

This Thursday (July 9th), there will be a webinar on the topic of single sourcing and in particular, extending Rich Client Platform (RCP) applications to the web using the Rich Ajax Platform (RAP) project.

Don’t know what single sourcing is all about? Well, if we look at the traditional definition from the publishing industry:

Sounds like a good idea?

How about we take that a step further and talk about source code and runtime environments:

In our definition of single sourcing, you’re able to take desktop applications built with RCP and run them on the web using RAP. During the webinar, Ralf Sternberg and Ruediger Herrmann will explore the differences between RAP and RCP that are especially relevant to the goal of single sourcing as much code as possible. This means that you’re able to reuse a lot of code and skills in single sourcing projects. If you’re still a bit fuzzy on the topic, a concrete example of single sourcing in practice was the Eclipse Memory Analyzer (MAT) project:

So what are you waiting for, please register for the webinar!

Tags: eclipse, rap, rcp, Single Sourcing, webinar

Enabling RCP applications to work with different locales is an essential requirement for server-side Eclipse setups. Multiple users are accessing the same instance of a running application concurrently, and each one should see the UI in his preferred language. Providing a server-side platform, the RAP project faced this problem too and we needed to find solutions to support multiple locales.

Recently I had the chance to discuss with Jeff McAffer how these changes could be integrated into Equinox. There are a number of subtasks to solve:

1. The NLS class must support different locales. Currently, translated strings are kept in static fields.
2. The extension registry must support reading in different locales. Currently, translatable strings in extensions are resolved once at startup and the results are cached.
3. There must be a mechanism to obtain the default locale for the current user and/or API to request a string in a certain locale.

I opened a new bug for the overall multi-locale topic and added patches to these bugs. Currently, comments show that there is no consensus on the suggested solution yet. These patches solve the requirements related to RAP, however, other projects may have different needs. If you have use cases related to multi-locale, please share your comments on the bug.

At any rate, multi-locale support is needed and it would be great to have it even in Eclipse 3.6.

So please comment on the bugs and help to push on this topic!

Tags: nls, OSGi, rap, rcp