The Eclipse plugin creation wizard allows to create OSGi bundles or Eclipse plugins.

The most notable difference is that the PDE plugin editor does not show the extension tab.

I recently wanted to use an plugin extension in a project which I initially created based on OSGi; therefore I wanted to enable the “Extension” and the “Extension Point” tab in the PDE editor.

To do this remove the line “pluginProject.extensions.false” from the file .settings/org.eclipse.pde.core.prefs. Re-open the “MANIFEST.MF” and the Extensions tab will show.

Many thanks to Neil Bartlett for sharing this tip via twitter.

Eclipse EMF provides the functionality to create universally unique identifier as described in A Universally Unique IDentifier (UUID) URN Namespace

To use this functionality just add a dependency to “org.eclipse.emf.ecore” to your plugin and you can start using it.

package de.vogella.emf.uuid;

import org.eclipse.emf.ecore.util.EcoreUtil;

public class MakeUniqueIds {
	public static void main(String[] args) {
		for (int i=0; i<100; i++){
			System.out.println(EcoreUtil.generateUUID());
		}
	}
}

For example you may get “_Fj9QPC0XEd-zxLXA4jfyXA” as a result.

Eclipse e4 is currently using this functionality to generated unique model Id's. The responsible class for this is "org.eclipse.e4.workbench.ui.internal.E4XMIResource".

Thanks to Remy Suen for providing this info on the e4 mailing list.

Eclipse e4 M4 has introduce a new look and feel for the tabs in the workbench. See Eclipse e4 M4 New and Noteworthy. Unfortunately the news and noteworthy document did not give information how to enable this feature.

The e4 mailing list has recently discussed this topic and Remy Suen was kind enough to provide this information. To turn this feature on you have to add the tag “newtablook” to your PartStack.

For example if you create an new e4 application with the e4 wizard you can add this tag via:

<children xsi:type="application:PartSashContainer" xmi:id="_vTa8kiuFEd-PeMLywHTM-g" id="_vTa8kiuFEd-PeMLywHTM-g">
  <children xsi:type="application:PartStack" xmi:id="_vTa8kyuFEd-PeMLywHTM-g" id="_vTa8kyuFEd-PeMLywHTM-g">
     <tags>newtablook</tags>
   <children xsi:type="application:Part" xmi:id="_vTa8lCuFEd-PeMLywHTM-g" id="_vTa8lCuFEd-PeMLywHTM-g" label="Main"/>
</children>

This lead to the following result:

Compared to the “old” look and feel.

For this topic see also Bug 305147 which discusses to move this feature to the CSS styling capabilities.

Based on my tutorial website I frequently receive questions from users. Some are very nice, precise, encouraging and some are of perceived bad quality. I also ask lot of questions in the Eclipse community and I try to ask good questions. Of course I frequently fail to ask good questions but at least I try.

So what makes a question, a good or even an excellent question?

I personally believe the following rules are a good guideline:

10 Golden Rules

1. Don’t be rude
2. Try to be as precise and as short as possible
3. Do your homework before asking (Google, search newgroups, read tutorials,…)
4. Try to ask one question at the time
5. Proof-read your question after writing it
6. Don’t expect others to do your work
7. Avoid private email if other channels exists
8. Remind yourself that people help you voluntarily
9. Read and follow up on suggestions
10. If you get a solution let others know

What do you think? Did I miss an important point?

For a detailed discussion of how to ask good questions see How to ask smart questions.

Since recently I try to deliver presentation with more visual effects based on the Presentation Zen approach. Of course one of the problems is to find nice pictures.

I’m aware of the following sites:

• stock.xchng
• Flickr

Thanks to Florian Heidenreich for pointing stock.xchng out to me in Twittter.

If you select images from these sites make sure to check the usage license, some may require permission from the author, others may ask you to give credit to the author, etc. Also make sure to give the author credit for his work in any case. A common approach to give credit to the author is to add a slide to the presentation which lists the URL of the pictures.

I personally really liked stock.xchng; it made it easy to find beautiful pictures which have a very permissive licenses. My first impression from Flickr was not as amazing; there are simple to many pictures to select from. Peter Friese pointed out a program ViewFinder for the Mac but I have not yet tried that.

The major pay site with beautiful artwork is istockphoto. Really great images but you have to pay for them.

If you know other web sites for nice pictures please let me know. Or perhaps you want to share your tricks how to select good images at Flickr.

There are lots and lots of exciting technologies available. Programming languages like Scala, Groovy, JavaFX, C# and frameworks as Spring, Grails, Lift, and lots more. Even within one area, for example the Eclipse framework, there are a legion of frameworks and projects which allow make things easier.

In my blog entry Predictable Irrational I discussed already that people have a tendency to leave too many options open. Having too many options open can be harmful as it prevents someone from putting focus into something. Unfortunately I’m not an exception to that tendency.

I decided that I should select 5 things for 2010 which I would like to have place a focus upon. This doesn’t mean that I won’t do anything else but I would like to define certain focus topics which I would like to gain knowledge about.

Ok and here is the list:

—————————–
Eclipse with focus on Eclipse e4
Hadoop / MapReduce
Google App Engine
GWT
Android
—————————–

Even though these are still big areas it is less then what I’m currently have on my list of things.

So why did I selected these topics?

Android is a fun platform and has a amazing programming interface which is intuitive, easy to use and fun. GWT is just to good to be ignored and the GAE provides such an easy mechanisms to host web application that I have to continue to use it.

Hadoop and distributed computing are clearly the future for the most interesting problem solving approaches. Hadoop might also provide a solution of the the usage of multi-core machines.

Eclipse, Eclipse e4 and the whole Eclipse community is very deeply implanted in my heard therefore I have to stay in this area. In addition I’m still highly influenced by the book “Pragmatic programmer” and I still believe that the advice “Know your tools well” is one of the best advices I have ever heard.

Which technologies do you think will be most relevant for you in this year?

A while ago I read the book “Presentation Zen” from Garr Reynolds. Garrs website can be found at Presentation Zen .

I must thank Oliver Gierke for the recommendation of the book.

The advice this book gives is actually very simple:

1.) Use lots of whitespace

2.) Avoid lot of text
3.) Avoid lots of bullet points

4.) Don’t treat powerpoint as a replacement for word
5.) Use a few nice looking pictures
6.) in extreme a presentation should be worthless without the presenter to explain it

You find nice introductions and examples in the following links.

How to create powerful presentations

Designing compelling presentations

If you have other good examples please let me know.

I really enjoy listening to presentations delivered in this format and if I have the opportunity to use this format I also have much more fun in presenting.

Dan Ariely is the author of the book “Predictably Irrational: The Hidden Forces That Shape Our Decisions” and discusses in this podcast his theories under the content of OpenSource with Dan Bricklin.

This is an older podcast, but well worth listening too. They especially discuss the difference between free and non-free on the consumer perception and how it influences our decisions. He continues how payments change the perception of people about social norms and work and how it influences their motivation. He also discuss how people tend to leave to many options open and what this may mean for OpenSource Software.

Dan Ariely “Predictably Irrational” and OpenSource. Careful links directly to the mp3 file.

Other podcasts of Dan can be found here:

Dan Bricklins Podcasts

This podcast is one of the most informative podcasts about social norms and Open Source I have found.

Eclipse Committer Election is starting as of 22. Febr. This is the first year I’m allowed to vote therefore I’m thinking what should guide my vote.

I recently read the book The Art of Community from Jono Bacon.

Jone speaks about the concept of Meritocracy.

A meritocracy is a system of governance in which its members are given responsibilities and recognition based upon achievements, merit, and talent. Those who are part of a meritocracy (such as in the Ubuntu and other open source communities) can make tremendous advances in respect and responsibility by simply doing good work. In these communities, money, class, and family connections have little or no impact on the ability to progress and build a reputation.

I believe that is an excellent concept and my vote will be guided by this principle. For an excellent summary of the committer project activities please see the How active is your-Committer blog entry from Ed Merks.

In addition to the involvement of the candidates in Eclipse projects I will also consider their community activity and attitude in the other Eclipse channels, e.g. their twitter activity, blog posts, email, etc.

I’m looking forward to the election; I think we have lots of great candidates.

Eclipse e4 has sometimes the tendency to do thing differently then expected. For example the modeled workbench may not show certain UI elements. In this case it is difficult to find out what is wrong.

This blog post tries to help to look inside the initialization process of an Eclipse e4 application.

In my e4 tutorial I write that you always have to start the application “org.eclipse.e4.ui.workbench.swt.E4Application”.

The implementation class is “org.eclipse.e4.ui.workbench.swt.internal.E4Application” and can be found in the plugin “org.eclipse.e4.ui.workbench” in. This instance of IApplication is created by the framework.

In this class you find the main entry point to your application:

public Object start(IApplicationContext applicationContext)
			throws Exception {

			}

The following line creates the mighty IEclipseContext.

IEclipseContext appContext = createDefaultContext();

In createDefaultContext() you find for example that e4 sets initially an empty Styling engine and you find the registration of the extension registry.

The next line is more interesting, its load the models. Here you can check if the model entries are available as expected.

MApplication appModel = loadApplicationModel(applicationContext,
				appContext);

Just in case you are wondering “M” Elements refer to the UI workbench model modeled with EMF. MApplication is the model element for the application and extends for example MContent which allows to store the IEclipseContext.

After a few lines of compatibility stuff the the model is added to the IEclipseContext and vise versa:

// Set the app's context after adding itself
		appContext.set(MApplication.class.getName(), appModel);
		appModel.setContext(appContext);

The next lines are interesting as they also reveal typical errors (I make). They load the parameters for “applicationXMI”, css stylesheets and the rendering engine. Here you can check if you parameters are read by the engine.

		// Parse out parameters from both the command line and/or the product
		// definition (if any) and put them in the context
		String xmiURI = getArgValue(E4Workbench.XMI_URI_ARG, applicationContext);
		appContext.set(E4Workbench.XMI_URI_ARG, xmiURI);
		String cssURI = getArgValue(E4Workbench.CSS_URI_ARG, applicationContext);
		appContext.set(E4Workbench.CSS_URI_ARG, cssURI);
		String cssResourcesURI = getArgValue(E4Workbench.CSS_RESOURCE_URI_ARG,
				applicationContext);
		appContext.set(E4Workbench.CSS_RESOURCE_URI_ARG, cssResourcesURI);

		// This is a default arg, if missing we use the default rendering engine
		String presentationURI = getArgValue(E4Workbench.PRESENTATION_URI_ARG,
				applicationContext);
		if (presentationURI == null) {
			presentationURI = PartRenderingEngine.engineURI;
			appContext.set(E4Workbench.PRESENTATION_URI_ARG, presentationURI);
		}

The last lines are for actually creating the E4Workbench and running it.

/ Instantiate the Workbench (which is responsible for
// 'running' the UI (if any)...
E4Workbench workbench = new E4Workbench(appModel, appContext);

The class “org.eclipse.e4.workbench.ui.internal.E4Workbench” is worth a look. It defines the fixed values for the possible parameters, e.g. “applicationXMI”.

The init() method is responsible for creating the UI in the method call Workbench.processHierarchy(appElement); where appElement is initially the MApplication. processHierachy() is then recursively called for all model elemements.

I hope this helps in evaluating and debugging the e4 platform. Let me know what you think.