Let’s assume for the moment, that in an alternate reality I can travel back in time to 2008. Once there, I meet a bright bunch of people that work on something called e5 (executive summary.odp). My summary:

“the runtime platform that is simple and appealing to _____ application developers”

Here’s what I would say to them:

e5 should take risks

When I became interested in Eclipse it was cool and disruptive. A real game changer. It is now the established tooling platform and understandably locked into perpetual refinement mode (Entrenched Player’s Dilemma). Make sure that e5 is equally game changing. Otherwise we are setting ourselves up to be disrupted.

At the EclipseCon 2008 we committed a “strategic sin”. We agreed that e4 would be compatible with 3.x. This limited the potential for e4 by forcing it to be something that is “in the box” vs. “outside the box”.

(taken from Death by risk-aversion by Kathy Sierra)

For e5 to be successful it needs to take risks. I don’t think that we need a better tooling platform. We already have a very good one with 3.x. And it’s still improving and not going away. Instead we need a runtime that provides something unique and remarkable. It must kick-ass in a new way.

e5 needs a driver

If you try to be everything to everybody, you will at best be mediocre at everything. e5 should be laser focused on being the best runtime for ___________ developers.

People tend to avoid specialization. It is perceived as a risk. However, if you ask a marketing person he / she will tell you that specialization is good. It’s your way to get noticed. It’s your foot in the door. You build a niche, become unbeatable and expand. Eclipse 3.x first became the tooling platform of choice, then client platform of choice for Java devs, then the modeling technology of choice for Java devs.

Unfortunately e4 lacks a driver that would help it specialize and focus. A driver, like the JDT was for the Platform. As far as I know, there is no major product build on top of e4. I believe that the current e4 (Feb 2010) is not yet appealing enough for web development or client development. It will not lure web-side Java developers away from Spring / J2EE / GWT. Or client-side Java developers away from RCP. Or Javascript folks away from jQuery / Prototype / Dojo. Or Rubyists away from Rails.

It is hard to pick the right driver. I don’t want to attempt providing an answer and limit your thinking. But feel free to share your thoughts in the comments.

e5 must be easy to learn & master

If you believe Eclipse 3.x is easy to get into, attend a beginner’s training. You will see how experienced Java developers struggle with the learning curve. And it’s not becoming easier with e4.

That is a problem, because it limits the mass appeal of Eclipse as a runtime solution. If you think it is a popular runtime, go to a Java User Group and see how few of the people who use Eclipse have written a plug-in for it.

It is in our human nature, that we tend to take the path that has the least resistance (read: easy) not the path that offers the most rewards (read: complex technology).

For e5 to be broadly successful it must kick-ass AND be easy to learn & master.

Looking forward to your comments,
Elias.

Tags: e4

Image credit: So gesehen@flicker, CC BY-SA 2.0.

I have been playing around with e4 (M3+Integration) today and so far I’m not impressed. I’m keeping an open mind, and may change my opinion at a later time.

At the moment however,  I would dare to say that e4 might be the “Windows Vista” moment for Eclipse. High hopes, but at the end of the day not groundbreaking enough to be interesting for a wide audience of developers (=regular java devs, web devs)

There are some things I like a lot and would like to see in 3.x, such as:

• CSS theming
• trident animations
• getting rid of the *Advisors

The biggest drawbacks in my opinion:

#1  NOT simpler,  just different

From my POV app development is still too complex for the avarage developer.  Here is why:

• Using dependency injection via annotations instead of having interfaces / abstract classes makes it very hard for beginners to figure out how to write classes. It is not obvious what annotations are available at any given point (@Inject, @PreDestroy, etc). The type hierarchy does not help for finding similar implementations – since there is no hierarchy
• The e4 workbench designer for the workbench model (.e4xmi) is nice, but unstable (failed to load my simple example). Editing the .e4xmi by hand or a tree-like emf editor is cryptic and less user friendly than the plugin.xml editor
• The plugin.xml is still necessary. So with the .e4xmi file we now have two .xml files that are relevant. I would like to see just one or none.
• Still too many technologies to master: Extension Points, OSGi, Workbench Model, EMF, Annotations, SWT, JFace.

“Simplify the programming model” is stated as e4’s first objective (e4-summary.odp), but  I don’t think this is true at present.

#2 Still big and intimidating

I often hear the Eclipse is big, bulky and intimidating. The Eclipse e4 download packs 230 MB and all the UI clutter we are used to – but many newbies find confusing.

#3 No killer feature

If a customer asked me about migrating to e4 for a product that launches in Q4 2010, I couldn’t really recommend it. At this point I don’t see any “must have“ features yet — especially for the folks that have 3.x apps up and running.

This is bad and a bit of a catch-22 situation:

• Without some “must have”  features people are going to stay with what they already know (3.x) instead taking the risk of using something new
• The longer people wait to use e4 the longer it will take to reach critical mass and a high level of maturity (i.e. most bugs found)

Looking forward to your opinions – especially if you disagree.

Kind regards,
Elias.

Tags: e4

We proudly present Riena 2.0 M5 – the first release in the 2.0 stream.  As you can see by the long New & Noteworthy, we have been very active in last six weeks. Read on for my five favorite new things:

1. Pluggable Marker Decorations

The new BorderMarkerSupport draws red-borders around a widget and replaces the standard ControlDecoration. You can select either error decoration style via the Look-and-Feel settings.

2. Enhanced Master/Details Widget

The Master/Details Widget automatically links a table with the details area on the bottom (or top). It is used heavily by some of Riena’s consumers. As a result we have been receiving good feedback and have added several requested features on this milestone:

• nicer border (includes button area, separates table from buttons with a single line)
• API to participate in the life-cycle (before / after selection, apply, remove, new)
• API to ‘suggest’ a new entry – it will show in the details area and Apply will enable
• API to tweak the margin and spacing of the Master/Details widget

3. Image Button Widget

The SWT Buttons have a system-defined look that is hard to customize (for example the background color cannot be changed). Riena’s ImageButton Widget emulates a button using three images (standard, hover, pushed state).

4. Multiple Default Buttons per Controller

Riena’s Controllers have a new API that supports several default buttons per controller. The default button has a blue glow when enabled. In that state it will automatically be pushed when the user hits ENTER (anywhere).

5. Controller Testing

Controller testing is now very straightforward and has been decoupled from the UI (widgets). Just subclass AbstractSubModuleControllerTest to get started. In addition your controller has to use the new API getRidget(Class, String) instead of getRidget(String). The package org.eclipse.riena.client.controller.test in the org.eclipse.riena.tests bundle has several examples.

Read the New & Noteworthy for additional details on these items.

Tags: helios, milestone, riena

A nice thing about Eclipse PDE is that it has mechanisms to make it very easy for developers to get started consuming your frameworks. Here are two of them.

Target Platform Templates

For runtime projects, such as Riena, RAP and Equinox, the first hurdle a developer faces is to set-up the appropriate target platform. A target platform is the collection of bundles that are available during compilation. Obviously if you ship runtime components they must end up in there to be available for compilation.

You can make this much easier for others by contributing a target platform template to the “New Target Definition” wizard. A developer can then select an entry in the “Template” drop-down and will instantly receive a pre-configured target definition. Much easier and less error-prone that recreating the target definition manually from step-by-step instructions.

Since the target definition’s payload can be provisioned over http, the developer only has to click on “Set as Target Platform” and is done. For details refer to the org.eclipse.pde.core.targets extension point.

Project Templates

Another way to help developers with their first steps is to provide a project template. This hooks into the last page of “New Plug-in Project” Wizard and pre-populates a new project with source code, binary content and appropriate plugin.xml and MANIFEST.MF files.

The templating mechanism has a lot of depth as you can manipulate data-models to dynamically craft the MANIFEST.MF and plugin.xml files. You can also define placeholder variables, such as $pluginId$ and use them in source templates. There are mechanisms to tie these variables to UI elements in the wizard pages. The developer documentation on the matter is somewhat superficial. At the moment your best bet is to check out and study the org.eclipse.pde.ui.templates project from the Eclipse CVS (/cvsroot/eclipse/pde/ui/org.eclipse.pde.ui.templates). It contains the templates that ship with the IDE and therefore plenty of examples. Complement this by reading the specification of the org.eclipse.pde.ui.pluginContent extension point and this introductory article on developer works.

Tags: pde, tips

We Riena committers smoothly shipped a fresh Riena Milestone last Friday, this time 1.2.0.M3 (download). Here’s the New & Noteworthy and the list of resolved items.

For the curious, here is the schedule leading towards the December release:

• 12/04 – 1.2.0 RC1
• 12/11 – 1.2.0 RC2
• 12/15 – 1.2.0

After that the work will start concentrating on the summer release, which is part of the Helios release train.

Tags: helios, milestone, riena

As you know, Eclipse can use “Team Project Set” files (.psf) to magically import code from various repositories. Thanks to Karl (294842), we committers can now set a project set url in our project’s metadata. This will link to a .psf-file from our project’s About page.

Here’s how this looks for Eclipse RAP:

After saving this file, you can use the “Team Project Set” wizard to download the latest RAP sources with a few clicks:

Now go and bug your favorite projects to provide a project set .

Kind regards,
Elias.

(follow me on twitter)

Tags: eclipse, rap, tips

Milestone #3 for Eclipse 3.6 is now available for download.

Here are the noteworthy changes up this milestone:

• 3.6 M3 – New and Noteworthy
• 3.6 M2 – New and Noteworthy
• 3.6 M1 – New and Noteworthy

My favorite change is the new support for software installation while running & debugging. This should be a huge time-saver for all developers who are adding p2 support to their RCP apps. It permits to do install operations in a launched application. Previously this was only possible after regularly deploying the RCP application via the export wizard.

Tags: helios, milestone

If you are at the Eclipse Summit Europe this week, here are some interesting talks about the work going on in and around Eclipse Riena:

* Eclipse RunTime Tutorial, Tue 9:00-12:00, Seminarräume 2-4 – This tutorial connects the dots between different runtime technologies, such as Equinox, Riena, RAP and EclipseLink

* Eclipse Riena Project – Overview and a new UI concept for RCP applications, Wed 11:20-12:00, Seminarräume 2-4 – This overview of Riena focuses on the framework’s UI concepts. Learn how to use navigation, styling and filtering to build better RCP applications.

* SWT Platform on QT – Overview and Demo, Thu 16:00-16:20, Seminarräume 2-4 – I’m very curious about this session. The screenshots I have seen looked very exciting. And the promise of taking advantage of QT’s extensive customization capabilities and build-in CSS support is appealing. Personally I’ve found SWT to be quite restrictive when it comes to styling and theming, so I am interested in all approaches that expand what you can do.

Kind regards,
Elias.

PS: I’m not attending this year, but several of my Riena colleagues will be there.

Tags: eclipse ui, ESE, riena

Sometimes you have two collections and want to know how they differ. It would also be useful to have a series of steps that transform collection ‘A’ into collection ‘B’ (or the reverse).

private static List list1 = Arrays.asList("a", "b", "c");
private static List list2 = Arrays.asList("a", "c", "d");
 
// Diff of list1 vs list2:
//  removed 'b' at 1
//  added 'd' at 2

With a little help from the class Diffs (found in the org.eclipse.core.databinding.observable bundle / package), it only takes a few lines, as shown in the snippet below. Thank you, Eclipse Databinding!

If you don’t see the snippet click here.

Tags: databinding, tips

The Riena committers have just done it again: Riena 1.2.0.M2 is now out the door (download). Here’s the New & Noteworthy and the issues fixed in this milestone. Read on for my personal favorites:

• New ridgets: ILinkRidget, IBrowserRidget, ITraverseRidget (for SWT’s Slider, Scale and Spinner widgets). Thanks to Florian from Redview for these contributions (snippets)
• IComboRidget now supports  CCombo: the CCombo widget works much better with our marker framework, since it supports different background colors (the regular combo does not!). Markers use background colors to point out required or incorrect data. Check out the new CCombo demo in the playground.
  
• MasterDetails improvements: (a) the MasterDetails widget now has an ‘auto apply’ mode, meaning that any changes done in the details area in the bottom will instantly be applied back to the original model in the table (snippet)
  (b) if you’ve edited the details and navigate away or hit the ‘New’ button, you’ll be warned that you’re about to discard your changes. If you find it annoying, you can also turn it off.
• Automatically synchronize enablement state of a label and another widget: Riena now has a mechanism that keeps the enabled-state of a label and another widget in lock-step. Example: you have a Label with the id “labelName” and a Text widget with the id “name”. If the text field is disabled, the label will be disabled too. The default strategy looks for the “label” prefix to associate two widgets with each other (i.e. labelXYZ <-> XYZ). However you can use the labelfinderstrategy extension point to provide a different strategy, if desired.

Kind regards,
Elias.

Tags: eclipse ui, helios, milestone, riena