Friday, 14 March 2008

Eclipse vs OSGI and Solstice vs RCP

This post is in response to the comment on my Solstice announcement linked above.


What is the difference between OSGi and Eclipse?


OSGi is the foundation of the Eclipse platform. Eclipse is built on top of OSGi.

OSGi has the concept of "bundles" which are modular Java components. Eclipse takes that concept and extends it to what most developers know are "plugins". A plugin though is just a bundle with a plugin.xml file. The plugin.xml file tells Eclipse how to deal with that particular bundle and defines extensions and extension points, more concepts that build on OSGi, though OSGi is predominantly service oriented.

The high level stack for Eclipse is:
  1. Java
  2. OSGi
  3. Equinox (an implementation of OSGi)
  4. Eclipse (SWT, JFace, etc)
I should point out that extensions and extension points are not only extremely useful for the UI/RCP side of things, but are a useful tool in general. My perference however is to try and remain as service oriented as possible using only OSGi services and interfaces that are in the specification and compendium where I can. That said, the Eclipse "plugin registry" can be used on any OSGi platform so developers shouldn't worry about tying themselves in to Eclipse if they want to use plugins and or instead of bundles.


Solstice vs RCP

Eclipse is a great platform for building modular rich applications for the desktop and there is certainly progress towards being able to deliver these applications over the web (I'm talking specifically of RAP). My understanding though is that RAP isn't mature yet and personally I'm not keen on AJAX or in fact having any dependancy on browser technologies. I prefer cross-platform runtimes such as Java or Flash Player.

For me the advantage of using Flex (especially when used with Solstice) over Eclipse RCP are:
  • Reduced footprint for installation of the software. Flash Player is small and the binaries for your application will be much smaller compared to Eclipse.

  • Easier to deliver the software to the users. Flex applications are delievered via the web, whereas Eclipse requires some installation.

  • Consistent platform for development.
    • Flash Player is identical across all supported platforms and according to Adobe at least some version of Flash Player is now present on 98% of all computers with FlashPlayer 9 coming in around 90%-95%.
    • SWT doesn't support all platforms in the same way.
    • Eclipse UIs look native.

  • Flex is easier to learn than RCP. I'm a software engineer / developer with more than 10 years experience (8 of that using Java) and found the learning curve for Eclipse to be very steep, but I persisted because Eclipse is "cool". Though I can create simple plugins quite quickly these days when I try and do something with Eclipse the complexity of the platform leaves me feeling unproductive. When I got my job with Arum I learnt Flex in a matter of weeks.

  • Flex allows developers to be creative with the UI. This is a duel edged sword really. Eclipse has a constistent UI (subject to native look and feel), but I have seen some stuff done with Flex that I couldn't dream of doing in Eclipse. Either that or you have to install or develop entire new frameworks to achieve something relatively (e.g. GEF for graphical editing, but it can't even rotate a text label!). The other side of that sword is that the UIs I personally produce still look very developer oriented (like an Eclipse app) and you really need that creative flare to do the exciting things I seen done with Flex. My focus is on the Java/Server side of things anyway, so I'm not too worried about that aspect of things. My colleagues are much better at Flex UIs than I am.
Conclusion

Flex is great but I felt as though I was missing out on the modular power that OSGi and the Eclipse RCP gives developers, which was my starting point when putting together Solstice. Using the Equinox and BlazeDS I managed to put a Flex UI in front of an OSGi container in an afternoon and I just carried on from there.

Flex has the concept of modules, but mainly for the puropse of reducing perceived load times. It seemed obvious to me that the dynamic ability of the Flash platform could end up creating an alternative to RCP.

Solstice is a good step towards that. Developers can still use the OSGi and all those good things that go with it (component oriented, service oriented) without feeling as though the only option for a UI is the Eclipse RCP or HTML website exposed through the HttpService.

Tuesday, 11 March 2008

MediaWiki Preview Eclipse View Plugin

I created the plugin (see link above) to render text files that I write in Eclipse using MediaWiki syntax. It suits my needs, but thought I would share. Simply drop it in to your Eclipse plugins folder and restart Eclipse. Then go to Window, Show View and select the MediaWiki Preview View from the Brindy category.

A view will appear that will attempt to render the current document as though it was a MediaWiki page.

Have fun!

Monday, 10 March 2008

Solstice alpha 0.3 released!

I'm very excited to announce that today Arum has released it's first of it’s kind modular rich internet platform combining Adobe’s Flex with OSGi has now been released as an alpha. Arum invites interested parties to download and try it out. For more information see the Solstice product page via the above link.

Solstice is based on the following technology:
  • Adobe Flex
  • BlazeDS
  • OSGi
  • Eclipse Equinox
  • Eclipse Equinox Servlet Bridge
  • Apache Felix
  • db4o
It's very alpha and we'll be doing more work on it as we develop our main product (DiDo), so in the mean time I'm prepared to field questions about it here or via the email address on the Solstice product page.