The Eclipse IAM/q4e team has released a new version.

I would talk about the new features, but there is an extremely nice New and Noteworthy page on the wiki which has saved me some work.

I would point out only a few features that I really like:

1. Autocompletion for dependencies in pom.xml. This is nicely done by installing the WTP XML editor if your eclipse doesn’t have it. Suggestions come from the new artifact search framework.
2. Using maven mojos in the workspace for your builds. This new feature will be really useful for maven plug-in developers… we want your feedback!
3. An upgraded embedder which allows the use of Maven 2.0.9 features (and plug-ins using those feaures).

Hope you enjoy using q4e as much as we enjoyed making this release!

This one is probably for newbies.

When providing a SelectionListener for doing a something when a SWT button is pressed, you’ll need to implement two methods:

Button b = new Button(container, SWT.PUSH);
b.addSelectionListener( new SelectionListener()
{
  public void widgetSelected( SelectionEvent e )
  {
    // TODO Auto-generated method stub
  }

  public void widgetDefaultSelected( SelectionEvent e )
  {
    // TODO Auto-generated method stub
  }
} );

However, only one of those methods will be called: widgetSelected

So you can save a couple of lines (which is always nice, specially when inlining the handlers like in these examples) by using SelectionAdapter, an implementation of SelectionListener with default implementation of both methods (which is to do nothing).

The final, shorter, core looks like this:

Button b = new Button(container, SWT.PUSH);
b.addSelectionListener( new SelectionAdapter()
{
  public void widgetSelected( SelectionEvent e )
  {
    doSomething();
  }
} );

I finally gave up on trying to resist. Curiosity was stronger… so now you can read my tweets at http://twitter.com/amuino

I’ve received notice from Jing (owners of screencast.com where q4e screencasts are hosted) that the allowed bandwidth is about to be exceeded… Thanks for the interest!

As a reminder, you can watch the WTP Screencast from Joakim’s site.

Q4E, the maven integration plug-in that has brought WTP support and Dependency Analysis to the Eclipse&Maven users is now listed at the Eclipse Plugin Central.

You can visit EPIC, rate Q for Eclipse and leave your comments.

It should also be much easier for new users to get to know Q for Eclipse.

Q for Eclipse, or q4e for short, is an open-source and open-development eclipse plug-in for bridging the gap between Eclipse and Maven. It is available from its google code home.

Since we believe that every eclipse user should be able to enjoy the benefits of using maven, we’ve proposed IAM (Integration for Apache Maven) as a new Eclipse project. Of course we offered q4e as an initial code contribution for the project. The proposal is discussed on its eclipse newsgroup (you’ll need to get a password from eclipse).

We’ve been working towards becoming a good candidate for an Eclipse project. The number of committers and the overall project activity has been growing, we’ve provided WTP integration, allowed sophisticated dependency analiysis…  and much more.

Now, we’re gearing towards the final step for donating q4e source to the IAM proposal… getting IAM into the eclipse incubator.

For this, we needed two eclipse mentors.

Well, we’ve got three

• Ed Merks, IBM: Eclipse EMF
• Thomas Watson, IBM, Equinox
• Brett Porter, Exist Global: Maven PMC, Apache member,…

Being an official Eclipse project can only bring good things to q4e. Since we will have more eyes on the project, more enhancements will be requested and more hands will join in.

If you use q4e, feel free to write some quotes on the IAM group. We always like to know who’s using q4e and where!

Exciting times are ahead!

If you have not yet read it, lets go and check the piece of code causing a deadlock.

In order to not spoling the fun, I’m providing the answer in the full post.

Here’s the code again, so you don’t need to jump between both posts:

public class Singleton implements Runnable {
  public static final String A_STRING = "Hello World".toLowerCase();

  public static final Singleton INSTANCE = new Singleton();

  public static Singleton getInstance() {
 	return INSTANCE;
  }

private Singleton() {
 	super();
 	launchThread();
 }

public void launchThread() {
 	synchronized (this) {
 		Thread t = new Thread(this);
 		t.start();
 		while (t.isAlive()) {
 			try {
 				wait(100);
 			} catch (InterruptedException e) {
 				// Interrupted.
 			}
 		}
 	}
 }

public void run() {
 	System.out.println(A_STRING);
 }

public static void main(String[] args) {
 Singleton.getInstance();
 }
}

This code basically calls a thread from its static initialization. This thread then tries to access some other static data on the class (A_STRING).

That’s the cause of the problem. Class initialization can only happen in one thread, so the second thread can not access A_STRING until the class is fully initialized. As pointed on the comments of the previous post, this does not happen with constant values, only when there’s a method call involved.

So the thread is waiting for the class to initialize.

The other side of the deadlock is the code in the launchThread which is waiting for the thread to end before exiting. Since the thread is waiting for the static initialization to finish, it never terminates and the static initialization never ends… and we have a deadlock.

Now, you might be wondering…

how could you think of such a complicated thing?

Well, it was in some code I was refactoring at work. It used to work extremely well… until I added a log4j logger with:

private static final Logger logger =
    Logger.getLogger(Singleton.class);

There it is, a static initialization with a method invocation. And the thread tried to use it, of course…

This is how a working code can be broken by an (apparently) safe change… So learn from my mistakes, be careful and be sure to have unit tests at hand.

Suppose you have this class:

public class Singleton implements Runnable {
	public static final String A_STRING = "Hello World".toLowerCase();

	public static final Singleton INSTANCE = new Singleton();

	public static Singleton getInstance() {
		return INSTANCE;
	}

	private Singleton() {
		super();
		launchThread();
	}

	public void launchThread() {
		synchronized (this) {
			Thread t = new Thread(this);
			t.start();
			while (t.isAlive()) {
				try {
					wait(100);
				} catch (InterruptedException e) {
					// Interrupted.
				}
			}
		}
	}

	public void run() {
		System.out.println(A_STRING);
	}

	public static void main(String[] args) {
		Singleton.getInstance();
	}
}

If you run the main method, it hangs in a deadlock. Can you see the reason?

It has just been announced…

Are you ready for it?

I’ve come across this interesting classification of developer types, by Frank Kelly.

It is a funny read… just try to assign a label to your workmates… and think which label they’ll apply to you :-).