javagruppen.dk - e4, the next generation Eclipse platform

e4, the Next Generation Eclipse Platform After 13 years, the Eclipse framework gets it second make-over. The new work is termed e4 and will be included in Eclipse 4.0. In the first make-over the run-time was replaced in Eclipse 3.0 with OSGi to get a better and more stable foundation for plug-ins. This time the user interface and contributions are modernized for use in Eclipse 4.0. In this session, we will see some of the insides of the new paradigms in e4.

Agenda
Introduction
Eclipse is… what exactly?
A little about the general Eclipse architecture
The goals and history of e4
The guts of e4
The timeline for Eclipse 4.0

Who Are You?
Who uses with Eclipse?
Who have developed plug-ins for Eclipse?
Who have al ready looked into e4?
Who knows about Dependency Injection?

About Me
Tonny Madsen, Founder and Owner of The RCP Company
20 years of experience in system development in major companies
Regnecentralen (now ICL)
Digital (now HP)
Anritsu (previously NetTest)
9 years experience as the Systems Architect of an 20+ MLoC project
8 years of experience with Eclipse and Eclipse RCP
Solutions Member of the Eclipse Foundation
Chairman of Eclipse.dk
Extern Lecturer at IT-University on Model Driven Development and Domain Specific Languages
Regular speaker at EclipseCon, Eclipse Summit, etc

Eclipse is… what exactly?

Eclipse – The Java IDE

Eclipse – The Tools Platform

Eclipse – The Application Platform Nordea Banking Desktop

IBM Lotus Notes Version 8

A Little About the General Eclipse Architecture Eclipse Platform Resources Workspace Help Update Team Web Server Filesystems Apache Search Navigator Intro Text Editors JDT CVS WTP Datatools VE BIRT Mylyn PDE Eclipse RCP Run-time/OSGi SWT JFace Workbench Preferences Jobs ICU Commands Registry CDT

Basically…
We need an architecture that supports distributed development over a large number of autonomous development groups
We need a component concept where components are loosely coupled and can be started (and stopped) independently
We need a way to describe external interfaces of components and dependencies between components
We need a way to only start the components as they are needed – also known as late activation
We need all this to work over multiple generations of components

Eclipse Architectural Components JDT CVS WTP Datatools VE BIRT Mylyn PDE CDT Eclipse Platform Resources Workspace Help Update Team Web Server Filesystems Apache Search Navigator Intro Text Editors Eclipse RCP Run-time/OSGi SWT JFace Workbench Preferences Jobs ICU Commands Registry

Your Typical RCP Application Application Platform Comm. Logging Help Update Auth. Auditing Apache Intro Base Add-on Add-on Add-on Add-on Debug Tools Data Model Eclipse RCP Run-time/OSGi SWT JFace Workbench Preferences Jobs ICU Commands Registry Add-on

Organizing the Platform
The software of an Eclipse system is based on the following terms:
Plug-ins – a plug-in is the basic unit of software
Fragments – a fragment is an add-on to an existing plug-in with additional functionality
Features – a feature is a number of plug-ins that is distributed and updated as a whole
Applications – an application is a Java class that implements a specific interface and is declared as such in the plug-in
Products – a product is a set of features or plug-ins along with the appropriate branding

The Short Story
1994: IBM develops VisualAge for Smalltalk – programmed in Smalltalk
1995: Java is released to a select group
1996: IBM develops VisualAge for Java – still programmed in Smalltalk
November 1998: OTI (Object Technology International – part of IBM) commissioned to develop new development platform for Java
7. November 2001: Eclipse 2.0 made Open Source
25. June 2004: Eclipse 3.0 released introducing Eclipse RCP
Framework make-over introducing OSGi
2009: Eclipse 3.5 released – known as Galileo
27. June 2010: Eclipse 3.6 will be released
Also known as Helios
June 2011: Eclipse 3.7 will be released
June 2012: Eclipse 4.0 will be released

The Goals and History of e4

Why A New Eclipse Framework
Simplify the Eclipse programming model
This will reduce development and maintenance costs and enable a larger developer community to leverage the platform in their own Eclipse-based applications
Enable the platform for use on emerging web-based runtime technologies
This will ensure the platform remains a compelling and viable application framework in a rapidly changing web technology landscape, and it will allow e4-based applications to leverage web technologies, while remaining insulated from specific technology choices that may quickly become obsolete
Broaden participation in development of the platform
This reduces the risks associated with building on a platform largely funded from a single source. Having a large and diverse group of commercial backers, will ensure the platform remains vibrant and viable over the long term

Main Technical Differences between Eclipse 3.x and e4
Application Model in EMF
Complete live model for the application – changes are reflected immediately in the application
Rendering the Application
Maps the model to the UI
Allows for a completely new look and feel without touching the internals
Allows support for different widget sets – even Adobe Flash or Microsoft Silverlight
Context
Contains the context/environment for all contributions
Brokers interaction with the framework: service lookup, service registration
Dependency Injection
Allows for POJOs for all contributions

Basic e4 Workbench Model Application Command Handler Binding Window Part Menu Part Description Toolbar

Basic Eclipse 3.x Workbench Model Workbench Window Workbench Page Editors Views Perspective Top-level menu Top-level toolbar Status line Perspective switcher Drop-down menu Local toolbar Workbench 0..n 1..n 0..n 0..n

Application Model

Rendering the Application
Provides the mapping of the model to a specific UI Widget Set
SWT
xWT
GWT
Adobe Flash
Macrosoft Silverlight
For some of the mappings, the concrete look can be customized using CSS
A render
Creates the needed widgets for the model element
Binds the widget and model element

The Current Context - IEclipseContext
Contains the current context for contributions
Name/Value pairs
Value can be POJO or IComputedValue objects
Created in a hierarchy
Children inherits all values from parent
Child contexts are used to override values locally
Used for all contributions
Views
Handlers
Wizards
Dialogs
etc
Supports
IClipseContext.runAndTrack – allows you to track changes in the values you use
IComputedValue – allows for late creation of objects and common behavior
Used as the base data store for Dependency Injection

Dependency Injection
Popular solution to the singleton problem:
PicoContainer
Spring
Google Guice
OSGi declarative services
Injection supported for all class members:
Fields, Constructors and Methods
Need not be public or protected
Marked with @Inject
Possibly @Optional
Value based on type of argument or field
Finds matching value from IEclipseContext
Possibly marked @Named(“name”)
Used with static methods on ContextInjectionFactory :
Object inject(Object object, IEclipseContext context)
Object make(Class clazz, IEclipseContext context)
Object invoke(Object object, String methodName, IEclipseContext context, Object defaultValue)

Code for Parts
The code that provides the “parts” of the application is ordinary POJO
No special inheritance – e.g. IViewPart or IWizardPage
public class Preview { public Preview(Composite parent, Realm workspace) { // Create UI ... } @Inject private MUILabel uiItem; @Inject public void setSelection(@Optional @Named(IServiceConstants.SELECTION) IFile input) { // React on Selection Changes } }

Adding Parts to the Application Model

Open Social Gadgets
What are OpenSocialGadgets
Gadgets are web-based software components based on HTML, CSS, and JavaScript.
Open Eclipse for a new set of developers
Examples
Remember the Milk http://www.rememberthemilk.com
Twitter Gadget
…

The e4 Story
First presented at EclipseCon ’08
20. May 2008: Mail to e4-dev „A radical approach to explore new paths for e4“
Platform designed from Scratch
Based upon an EMF-Application-Model
No statics, no singletons, usage of Dependency Injection
Based on OSGi-Services
14. January 2010: 1.0M3 released
27. June 2010: 1.0 will be released

If You Want to Know More about Eclipse
The foundation:
http://eclipse.org
The Danish User Group:
http://eclipse.dk
The training:
http://www.eclipse.org/community/training/classes.php
Resources on Eclipse:
http://www.eclipse.org/resources/
Consolidated Blog:
http://planeteclipse.org/

If You Want to Know More about e4
The Project:
http://www.eclipse.org/e4/
Downloading e4:
http://download.eclipse.org/e4/downloads/
The Wiki:
http://wiki.eclipse.org/E4
The training:
Not yet, but coming after the Summer
Tutorials on e4:
http://www.vogella.de/articles/EclipseE4/article.html
A “create an application” tutorial from Lars Vogel

Eclipse.dk – The Danish Eclipse Society
Eclipse.dk was created in Marts 2007 as a meeting place for everyone interested in the Eclipse ( www.eclipse.org ) platform.
The purpose of Eclipse.dk is as follows:
To promote the knowledge of Eclipse in Denmark.
To create networks amongst danish Eclipse-users and developers.
To build knowledge on Eclipse in Denmark, especially
In danish institutes of higher education.
Between danish companies developing applications based on Eclipse.
Create and maintain a web site on Eclipse for danish users – eclipse.dk.
Strengthen the relations between danish and international Eclipse-users and organizations.
The eclipse.dk society has members representing not only vendors of Eclipse-based products and services, but also users of the platform and representatives from institutions of higher education.

javagruppen.dk - e4, the next generation Eclipse platform

by Tonny Madsen on Nov 12, 2010

Accessibility

Categories

Tags

Upload Details

Usage Rights

Statistics

javagruppen.dk - e4, the next generation Eclipse platform — Presentation Transcript