Success stories like MineCraft keep popping up from time to time. Behind the scenes it’s built with Java. As of today MineCraft has ~24 million registered users, of which ~5 million have bought the game. Most of them with a price of €19.95 (but they did start with a huge discount). In the last 24 hours, 60K people registered, and 8K people bought the game. (Source: http://www.minecraft.net/stats).

We keep hearing that desktop apps are hard to install and maintain. I don’t think Java is a cumbersome environment if 12-16 year boys and girls manage to get tens of thousands MineCraft servers running at their homes. Millions of regular Minecraft players run Java apps without an issue. There are thousands of plugins and mods written in Java for MineCraft server and client. Java is great for that but it’s way too easy to bash the platform if the real problem is usually in the product and distribution!

Let me share with you some of the user conversion stats in one of our own desktop apps, TimeGT. TimeGT is a task and life management app that is written in Java. It has an installer for Windows that includes Java runtime environment so user doesn’t have to install Java by herself. So far 99.1% of users who register their account at the website end up installing the app successfully and logging in with their username. That means essentially that every ~100th user has an issue with the desktop setup. For TimeGT case it’s very likely Mac issue as we don’t provide a .dmg file and running it in Mac is painful.

Eclipse IDE requires Java. OpenOffice requires Java. So does Adobe Photoshop. I believe it’s safe to say that you can still build great and massively popular stuff without falling into building on top of technology which was initially poured over with millions of dollars mostly to sell more ads, own more of your screen estate. Don’t get me wrong.
Of course web apps are perfectly natural for oh so many user cases. I’m still overly excited and thankful that web got a technological and distrubution kick at this scale. Oh. And building beautiful things is so much easier with the web instead of hacking with a Java Swing or SWT UI toolkit. Just know where the fine line is.

The road ahead with desktop and Java

I guess the challenges evolve around maintaining updates and supporting platforms (read: devices).

I’m not worried about the updates. It’s a feasible engineering task. In TimeGT we have automatically pushed updates (yes, requires restarting your app but so does Android and iPhone app!).

But getting your Java app to devices like Android and iPhone is not fun. I’m not sure how it all gets to a sensible place where you don’t have to over-abstract for the sake of single-sourcing yet avoiding idiotic rewriting of app in different languages.

Small footnote on desktop coding experience

While Eclipse remains to be the most popular IDEs around and provides a wonderful Java editor and extending capability, it scares me how its initial advantage of being fast and snappy is diminishing and people keep turning their heads toward vi/vim, SublimeText 2 and TextMate even for Java and Scala. You might think that a real IDE with full AST parsing and class model navigation is required for any reasonably sized projects but I keep seeing people hacking more and more with their text editors. I hope to see a change here. Get an IDE that is as fast for coding as vim.

Eclipse core itself is super fast and gets improved all the time but as with Chrome browser – plugins slow life down. There should be more control on seeing which plugins conserve most resources and a quick method to kill them, just as you close tabs in Chrome.

One project contains many different file types, they must blend into one hacking experience.

While on it also added keyboard shortcut so you can switch on-off the wrapping using Ctrl+Alt+W (M1,M3+W in “Eclipse Language”).

Trust me, it’s a useful plugin : )

Latest version can be installed from the update site: http://ahtik.com/eclipse-update/

Word Wrap project site

Thanks to the shortcut I’m not even waiting anymore to have it fixed in the very deep core of the Eclipse platform as the changes would be massive and simply switching it off before launching a debugger is good enough for now.

For a quick background, BPMN (Business Process Modeling Notation) is the leading standard for business process modeling managed by the OMG. A new version called BPMN2.0 (released January 2011) brings numerous changes to the table, most importantly increasing the consistency and integrating orchestration and choreography in a way that makes BPMN 2.0 a great choice for business process engines.

Over the past few months we‘ve been very excited to work on a new BPMN2.0 Visual Editor for Eclipse. It is free and open source, hosted at github. This github repo is a temporary place and will find a new home soon.

BPMN2 Editor is built on top of the awesome Graphiti modeling framework and behind the scenes uses BPMN2 EMF metamodel.

For more details check out the more detailed post about the BPMN2.0 visual editor by Kris from jBPM.

Check it out, have fun, contribute, report issues and bear in mind that it’s still beta and actively developed ; )

Java JRE in itself supports proxies for HTTPS but it does NOT support SSL connections over proxy. For that you’ll need to create a separate proxy tunneling socket and layer it on top of the actual SSL connection. So far so good but there’s a nasty exception that can take you ages to figure out:

Caused by: javax.net.ssl.SSLException: Received fatal alert: unexpected_message
	at com.sun.net.ssl.internal.ssl.Alerts.getSSLException(Alerts.java:190)
	at com.sun.net.ssl.internal.ssl.Alerts.getSSLException(Alerts.java:136)
	at com.sun.net.ssl.internal.ssl.SSLSocketImpl.recvAlert(SSLSocketImpl.java:1682)
	at com.sun.net.ssl.internal.ssl.SSLSocketImpl.readRecord(SSLSocketImpl.java:932)
	at com.sun.net.ssl.internal.ssl.SSLSocketImpl.performInitialHandshake(SSLSocketImpl.java:1112)
	at com.sun.net.ssl.internal.ssl.SSLSocketImpl.startHandshake(SSLSocketImpl.java:1139)
	at com.sun.net.ssl.internal.ssl.SSLSocketImpl.startHandshake(SSLSocketImpl.java:1123)

There can be many reasons but one of the unexpected ones — make sure to add

Pragma: no-cache

to your http proxy CONNECT request header! Otherwise you’ll get this exception.

To find out we (me and Ivar) did a little test-drive using recently announced Glassfish Eclipse Bundle that contains Eclipse IDE with bundled Glassfish J2EE server, optionally JDK and a lot of integrated plugins to get you started quickly.

After cutting out all the downloading, startup etc delays we ended up with a surprisingly short 10min demonstration! It was interesting that we barely wrote any code or XML — see for yourself! Tricky part was initial setup to get all the jars and configurations right — must be followed pretty much the same sequence as in the video!

Ok, here it comes, have fun Probably adding a few annotations and audio would help?

Any feedback is more than welcome!

The relation to Eclipse is simply the fact that big part of eclipse.org is a great example of good test coverage built on top of jUnit. Plus, it was literally pulling my hair out in one of the eclipse-related testing-suites.

I stepped into this a few years ago while bug-fighting a test class that had unexpected initialization.

Pretty sure that many of you know the answer but definitely fun outcome!

As everyone can simply run this snippet yourself I won’t delay approving comments, I’ll just accept them whenever I get a free moment. This comment system here has captcha but additionally all comments must be approved manually.

import junit.framework.TestCase;
public class MyTest extends TestCase {
private static int count = 0;

{ count++; }

public MyTest() {count++;}

public void test1() { System.out.print(count); }
public void test2() { System.out.print(count); }
public void test3() { System.out.print(count); }

}

I’m sure some of us don’t always take this behavior into account

After figuring this out, SPECIAL fun is a bit modified case:

import junit.framework.TestCase;
public class MyTest extends TestCase {
private static int count = 0;

{ count=count*2; }

public MyTest() { count++; }

public void test1() { System.out.print(count); }
public void test2() { System.out.print(count); }
public void test3() { System.out.print(count); }
}

For this last snippet I think without running it you won’t figure it out At least I didn’t..

UPDATE: Decent in-depth hi-tech doc about java init http://www.artima.com/designtechniques/initialization7.html

UPDATE2: Correct answers were 666 and 777.

You are allowed to change ONLY the main method! Of course changing sysout line is out of question.

You can leave your answer in comments and I’ll publish/approve them together with the solution.

[java]
public class InstanceDemo {

public static void main(String[] args){
MyClass cl1 = new MyClass();
MyClass cl2 = new MyClass();
System.out.println(cl1.ocl==cl2.ocl && cl1!=cl2);
}

private static class MyClass extends java.util.ArrayList {
private final Object ocl = new Object();
}

}
[/java]

I’ll post the correct answer in 24h

UPDATE: Was not that hard afterall! ~45 correct answers.

Yes, clone() was the answer I was looking for:
[java]MyClass cl2 = (MyClass) cl1.clone();[/java]

Ed Merks surprised with a nice solution:
[java]
//Add this line as the first line of main.
class MyClass extends InstanceDemo.MyClass {
Object ocl = null;
}
[/java]

And a lot of people took the hard-core way:
[java]
Field field = cl1.getClass().getDeclaredField(“ocl”);
field.setAccessible(true);
field.set(cl2,cl1.ocl);
[/java]

I have seen this to be pretty standard practice (and have done this myself too).

Be aware that SimpleDateFormat#format(..) is not thread-safe and thereby for most of the cases you should not use this as a static field in server, Eclipse RPC or any other multi-threaded environment.

SimpleDateFormat is internally using field “calendar” that is set with each #format(…) method call so that pretty much breaks the thread-safety.

Bytes in java are always signed and are quite horrible to use because of the casting and weird side-effects (or I’m just stupid enough to call it weird).

But we need unsigned bytes quite a lot. Most of the time for reading various streams (networks, 8bit strings etc) some text stream you still end up with byte streams.

There is a nice trick converting them from signed to unsigned in case you want to get normal 0..255 range for the chars.

byte mybyte = -104;
long mynewint = mybyte & 0xFF;

Hope it helps!

I had quite a nice puzzling while trying to find some easier way. Is there?

Consider a code like this:

if (isConfigurable()) {
  Bundle bundleCopy = bundle;
  Preferences[] preferencesCopy = new Preferences[1];
  preferencesCopy[0] = new org.eclipse.core.internal.
			preferences.legacy.PreferenceForwarder(
			this, bundleCopy.getSymbolicName());
  return preferencesCopy;
}
return null;

Do you see what’s wrong there?

The problem is that if your #isConfigurable is always FALSE then your code still:

1. loads PreferencesForwarder class
2. initializes all PreferencesForwarder’s static variables
3. forces Preferences plugin to load

Always, if possible and makes sense, isolate your class loading into a simple Runnable inner class if there is some static init or plugin activation trigger involved!

Then the code would become:

if (isConfigurable()) {
  final Bundle bundleCopy = bundle;
  final Preferences[] preferencesCopy = new Preferences[1];
  Runnable innerCall = new Runnable() {
    public void run() {
      preferencesCopy[0] = new org.eclipse.core.internal.
			       preferences.legacy.PreferenceForwarder(
				 this, bundleCopy.getSymbolicName());
    }
  };
  innerCall.run();
}
return null;

When you think of it – this pattern is somewhat similar to the singleton pattern implementation – the one of the very few thread-safe and fast singleton patterns that is bugfree and truly lazy!

Quoting wonderful singleton impl from wikipedia:

public class Singleton {
   private Singleton() {}
   private static class SingletonHolder {
     private final static Singleton INSTANCE = new Singleton();
   }
   public static Singleton getInstance() {
     return SingletonHolder.INSTANCE;
   }
 }

(OK, to be fully honest, since java1.5 you can also trust volatile flags but – trust noone, use the old stuff:P)

For the reference, the PreferencesForwarder example was taken from the org.eclipse.core.runtime.Plugin#getPluginPreferences class and modified a bit.

UPDATE: This post is not fully correct! Never assume something to be true even if it comes from a trustworthy source like eclipse core runtime source. Please see the comments for explanation!