It was three years back (January 13th, 2009) when I posted on our Webnode site that we need some better web for presentation than our project site on Google Code. But then we found we can’t post bunch of HTML files (Javadoc) on Webnode – and with mime-types SVN props we can do that on Google Code… oh, how quickly things change.

Webnode site could be good if Java Simon gained some bigger momentum on our side – more committers and contributors, people writing blogs or tutorials or success stories (or not so success stories too if they can help ). But this did not happen and I felt as rather annoying obligation to update this site. Especially because the edit functionality is on a separate URL – editing a Wikipedia page or a blog post on WordPress is always just one click away – but not so on Webnode.

Three years later I decided to redirect javasimon.org on our Google+ page because it is so much easy to update, posting even very short posts is not inappropriate (which would be on a blog) and it’s just so much closer to my way of living on the Internet right now. I’ll go through javasimon.webnode.com and it will soon be a matter of past.

Last time I discussed some changes from version 1 to version 2. And to preserve the little from Webnode site that has any “historical” value I hereby copy one blog post covering just these differences:

Major changes in the core of the Java Simon v2
2009-01-28 14:30
While there are some important extensions to the Java Simon (JMX, Spring integration, etc.) there are a few important changes in the core part of the API that are probably even more important. If you’ve already managed to use Java Simon 1 I strongly suggest that you use version 2 even in its alpha stages. The thing is:

• If your project is finished or close to finish (month or two) stay with version 1.
• If your project continues and you’re just experimenting with Simon, definitely use version 2! There is v2-alpha1 which is basically rework of the v1 after a few changes in Stopwatch. If there is newer alpha out (check Featured Downloads on the right on our project page) take that one of course, because it contains more features from v2.
• Version 2 is planned to be out during March or April 2009, which is really soon.

Now what are the changes and why we made them?

• Important change happened in the Stopwatch. While in the v1 it contained various start/stop methods that took care of multi-threaded environment now it has only one start method and this start doesn’t return this anymore but it returns new Split object instead. You have to take care of the Split object, you have to take care of your multi-threading, you have to call stop method on the Split. This makes our code safer as the Stopwatch doesn’t contain internal maps that were prone to memore-leaks if client forgot to stop some split. Thanks to Erik van Oosten and his great Java Simon evaluation.
• Based on the same post we changed sample methods so that they return Java Bean objects now instead of the field.
• While in v1 you had to use SimonManager now you can use non-static Manager implementation directly. SimonManager still stays your favourite convenient class full of static methods, of course. This allows to have multiple separeated Simon hierarchies which may be handy in Java EE environment.
• To provide some extensibility for the API we introduced Callback interface. This allows to hook onto various events and process these events in any way you want – to log them, send JMX notifications, whatever.

There are more features to come with version 2 and I covered only those in the core part of the API. Stay tuned, download, use, test, let us know what you think.

Now let’s take a look at those Callbacks. Based on good-old Observer pattern, Callback is a listener that performs some actions on various events. First question was where the Callback should be registered – and we decided that Manager will hold its Callbacks. We didn’t want to scatter Callbacks across various Simons because typical usage would lead to a situation where many Simons call (and point to) the same Callback. We rather decided we will centralize Callback management on a Manager (that is per Manager of course) and bring some way how to filter events based on Simon name for instance.

Simple example of Simon is in our CallbackExample:

    SimonManager.callback().addCallback(new CallbackSkeleton() {
           public void onStopwatchStart(Split split) {
               System.out.println("\nStopwatch " + split.getStopwatch().getName() + " has just been started.");
           }

           public void onStopwatchStop(Split split) {
               System.out.println("Stopwatch " + split.getStopwatch().getName()
                   + " has just been stopped (" + SimonUtils.presentNanoTime(split.runningFor()) + ").");
           }
       });

       Stopwatch sw = SimonManager.getStopwatch(SimonUtils.generateName());
       sw.start().stop();

When you work with Simon (last two lines) you don’t care about Callbacks – they will be called. Their configuration can be based on some configuration and they should do whatever you want to hook on various Simon events.

BTW: If you use Java Simon 3.1 method onStopwatchStop is still called stopwatchStop. This is quite serious flaw and poor choice of method name on my part (and I’m terribly sorry for that). While this method doesn’t show it clearly, there was another method – clear (now onManagerClear). This method is called – as you may guess from the new name – when clear method on the manager is called. Let me explain composite callbacks first to show you the whole problem…

To add more callbacks to the manager is all right but if you want to filter Simons (by name, for instance) that fire an event on a Callback you actually need to do it in the event itself. Or wrap the Callback into another one – that is exactly what FilterCallback idea is all about. Another thing is that you may need to call various callbacks for the same filter – to group them – and that is what composite callback does – holds more callbacks (children) and relays the event to all of them. There is no interface CompositeCallback – instead all these methods are on Callback already, but they are not implemented in the CallbackSkeleton for instance (used in the example above). There is one implementation called CompositeFilterCallback – and you probably can guess what it does. It can hold more callbacks and call them when the common configured filter is passed. See CallbackFilteringExample for simple use case.

Now guess how people tried to remove callbacks from composite callback. It’s just a collection of callbacks after all, right? Ah, method “clear” must do exactly what I need here. But it didn’t. And if you didn’t implement this event method (which is not very common, but JmxRegisterCallback is nice example where it is very handy) it simply did nothing. There was method to remove one callback, but not all of them (this one was in SimonUtils). This is all finally fixed with version 3.2 – all names are much better and removeAllCallbacks is in the Callback interface.

JMX is nice example why we needed callbacks just as much as we wanted to offer them to our users. There are two ways how to access Simons via JMX – you can use single point MX bean, or let Simon instantiate MX beans per Simon. The latter however requires some actions when Simon is created, destroyed or the whole manager is cleared. I mentioned JmxRegisterCallback already – check how it’s done there. Now the Simon manager knows about Callback mechanism – but it doesn’t have to know about JMX – or anything else you want to drive by these events.

Split introduction and Callbacks are two very important changes that happened in version 2 – and these things are now well proven and will probably last (though some names can change as will happen in version 3.2 ). Next time I’ll try to wrap up the rest of the story.

I’m really proud about our newest Java Simon release (3.1.0) and I decided to share the mail written to javasimon@googlegroups.com also here on my blog:

Dear Java Simon users

Firstly – version 3.1.0 was released on New Year’s Day – more about it
on our project site:
http://code.google.com/p/javasimon/

We announced it also on our new stream on Google+ (it should be
available for non-google users too):
https://plus.google.com/b/115141838919870730025/115141838919870730025/posts/ZpmYGp9F2yp

Secondly – about Google+ – we decided to pull down our Webnode site
because it was a bit cumbersome to maintain and add new posts there.
Instead we are moving to the aforementioned Google+ page.

Direct link: https://plus.google.com/115141838919870730025/posts
Short link: http://gplus.to/javasimon
Or just use our domain! http://javasimon.org/ or http://www.javasimon.org/

This way it should be easier for us to post more often even smaller
facts about your favourite monitoring library.

Thirdly – Happy New Year to you all, update and share your thoughts, I
feel very well about the last release. We’re working on 3.2 already,
with our new commiter (Gerald) we should be able to deliver simple
embeddable web console too, so there is a lot to be looking forward
to.

Best regards and wishes

Richard “Virgo” Richter

You are welcome – and encouraged – to add Google+ page into your circles of course. And once more – Happy New Year – as this is my first post here in 2012.

If you blog on WordPress you probably got the mail too. It was just lovely dot after the whole year on the Internet. Especially with sentences like “your writing has staying power”. That made my day. Here it goes – full of it is behind the link at the bottom:

The WordPress.com stats helper monkeys prepared a 2011 annual report for this blog.

Here’s an excerpt:

The concert hall at the Syndey Opera House holds 2,700 people. This blog was viewed about 26,000 times in 2011. If it were a concert at Sydney Opera House, it would take about 10 sold-out performances for that many people to see it.

Click here to see the complete report.

PS: I forgot to mention that my wife’s blog about cooking – in Slovak only! – made three times bigger numbers. With only two new posts this year she reportedly sold out Medison Square Garden three times (I was rather compared to Sydney Opera – another nice touch of the report).

So let’s start with the previous Christmas sales on Steam. I bought Mass Effect 2, King Arthur Pack, Railworks (now updated to Train Simulator 2012), Dragon Age: Origins, Crysis Complete, The Ball and Burnout Paradise. I even new I may not play some of them, but for the gamer it would be a sin not buy it when it’s so cheap. I want to play The Ball just because it’s made by Hourences and the team of other great mappers/modders who had been around Unreal engine and Unreal Tournament quite some time – and the game is original too.

In the last few years Mass Effect may be my favourite franchise – it’s a great shooter and I even forgot it’s RPG. Not that I have anything against RPGs – on the contrary – lately I played more RPGs of various types to my own surprise. I stopped playing other games and first I had to go through Mass Effect 2 (twice, different gender, different specialization). While you don’t exactly save the galaxy in front of the whole council (dead or alive ) like in the first part, the continuation is probably more epic on the whole. Not that I didn’t have any gripes about the game, I can’t remember them now – but I can remember how great the game was. As I remember the VI announcing another customer in line from the first part I still have vivid memories of quite a lot of scenes from ME2. This game flows well and it’s getting bigger and bigger towards the end. If you like sci-fi RPGs (or even shooters and can survive a few dialogues) then this is an absolute must-have. ME1 was great, ME2 is greater, with less annoyances, more variability in scenery, more subplots and one really nasty boss at the end. Fun factor 5/5, frustration 0, length just right.

King Arthur was the game I spent the start of the year with (after ME2 that is). I was really surprised with the blend of the Heroes M&M turn-based strategy (on a map that reminded me good old Defender of the Crown) and RTS battles – this all spiced up by simple text-based quests and some economy. I was really surprised how playable the game was. In the middle of it I thought I will loose because opponents’ knights (heroes) started to be very strong while I underestimated the power of some spells, but somehow I managed to outmaneuver them in the end. If you like strategies, try it. On the RTS battlefield it’s often about you knowing how to play around key areas and you may destroy a few armies with a single one. Maybe hard-core players would object, but I – casual nearly-ex-gamer – appreciated this concept. Fun factor 4/5, frustration 0, length quite long as expected. Typical “just one more move and I’ll go to bed” game.

Batman: Arkham Asylum is a bit difficult story. I had troubles to save single player games originally – I even wanted to play cracked version because of the stupid Windows Live service. But I figured out the offline profile feature (hidden in an unbelievably stupid way) and then I started to play. Another serious issue – no way to change controls. I’m ESDF guy, I touch-type too. WASD drives me crazy and when I want to press 1, I always press ` (key to the left) – well… because I touch-type! Not to mention that one disabled guy told me how missing controls customization can render the game unplayable for them. But back to the game itself. The story, visuals and all was quite reminiscent of Bioshock (both Unreal 3 engine games, by the way). I liked special tactics Batman can use, detective mode, gargoyles, visuals – this all was very good. You were really in the middle of Batman’s story with may heroes I didn’t even know. Boss fights were interesting, each of them a bit different. If you had any problem, game gave you some hints – I liked this as I’m less and less hard-core player and more and more a casual one. However here and there you played with different camera than over-the-shoulder and it made controls even more difficult (some boss fights mostly). You could take it as a minigame though. For one reason or the other I wasn’t so sucked into this game in the end, but I finished it after a few breaks (a few months mostly). Fun factor 4/5, frustration 3 (Windows Life + controls + camera), length just fine for me (progress meter counts also riddles, so you may probably end around 60% if you don’t care for the riddles). Recommended? Why not, but I don’t plan playing Arkham City.

In the middle of the year I suddenly got a strong need to play Half-Life 2 again – with both Episodes too, of course. As scripted this FPS is, it is simply great. Even the second run. I realized how many scenes in this game are simply so great. The river, first gravity-gun practice, “We don’t go to Ravenholm”, blocked bridge, Nova Prospect fight while waiting for Alyx, all those striders, Overwatch Nexus, Citadel… all of it! And then the Episodes – reactor hot-fix, run away to the station, fleeing the city, jumping over a broken bridge, Alyx down and up again, ambush in a homestead and amazing finale of the second episode. Without making any choices, without any active dialogues, the story is just great and I think I’ll probably have to go through it some other time again. Not to mention that it has great commentaries too – these just underline how well-thought this game is. Fun factor 5, frustration 0, length just fine – I even consider the main game quite long for a shooter, but I bet it’s short for others.

I was nicely surprised by Anomaly Warzone Earth. Simple, arcadish, and as goes with turret defense – very addictive. The concept of playing against the turret defense is smart, it is spiced up with a lot of specific details on particular maps and while this game was shorter in overall, it was also cheaper as it is no AAA title. Still the production was surprisingly good and the whole game is just smooth. Worth a few bucks for killing a few evenings, really. Fun 5, frustration 0, length could be longer, but OK.

Frozen Synapse on the other hand was too much for me. You have to dedicate more time to this game, it’s not good for a casual player I’d say. I expected some kind of Laser Squad I remember from ZX Spectrum (or the horrible port on PC) – but then – I had much more time (and much less games) back then. However the concept is interesting but without going for a multiplayer it’s probably not worth it. Fun factor 3 (single player), frustration 0, length – no idea.

And then there’s The Elder Scrolls IV: Oblivion. I played Morrowind before, but after some time I just gave up. Maybe I chose more boring class, but I guess different class wouldn’t change my mind. Oblivion is more or less like Morrowind – but more fun. Both these games are BIG. A lot of locations, a lot of characters, a lot of quest. However I lost my goal after some time. Oblivion is far better from this perspective than Morrowind, not only because it’s newer. But still – after shutting a few Oblivion gates I started to loose my focus, I didn’t know where to go and what to achieve in this game. This game is very good and having less other games and more time I’d probably play it (and maybe I’ll return to it). System is better than in Morrowind, a bit simpler, leveling goes more naturally, movement around the world map is faster – this all makes the game great. But when I compare it with games like Witcher and Dragon Age Origins (which I’m playing now though I hardly started the story) it’s easy to get lost here. I like RPGs that lead the player a bit (or more) – Witcher, Dragon Age, Mass Effect – these are much better in this aspect. For Oblivion the fun factor is 4, frustration 0, length was too much for me.

However, there is one easy way how to try a lot of games for little money. Wait a year or two and buy it during holidays sales if you’re not sure if you really want it. I remember buying Unreal Tournament 3 in metal case for quite a lot of money for my taste – and I was utterly disappointed by the game (though I loved UT99/2004). That’s why I hate to give anything more than 30 for a game I’m not sure of. Having Dragon Age 1 with all of the DLCs (another reason why to wait a bit) for 20 is much better deal then. I rather spend a lot of money on a lot of games risking I’ll not play a few of them than spending even more money on a few ones, half of them probably more or less disappointing.

And what were your favourite games in 2011? Let me know, anonymous comments are allowed as well – as always.

Working on our first version of Java Simon I learned a lot from my colleagues too. While we shared our views all the time on the OSS library we somehow did even better than on our common (resource limited) projects. We also knew that library must be even cleaner and better than some Information System developed once – often without proper support budget. One guy insisted on finals whenever possible (which I’m not fan of) and he also vigorously refactored methods with boolean flags – and I originally disliked this change. In Simon interface we had methods like:

Map<String, String> sample(boolean reset);

Now we have much cleaner two methods instead of using boolean parameter – not to mention that we have Sample object instead of Map used in early versions:

Sample sample();
Sample sampleAndReset();

Not that we don’t have any method with boolean flag – but the most prominent one is rather management one compared to sample methods:

void setState(SimonState state, boolean overrule);

Generally I don’t like using boolean flag parameters because they are hard to read when you see just plain code. If they are replaced with enums (where suitable) readability goes up instantly. If they are split to two methods – especially when one of them is rather default (like the sample without reset) – even better.

Working on an OSS library (or any other library – even a private one) you have to think way harder (or rethink more often) how to organize your interface, packages and all. I personally hate backward compatibility as an ultimate decision and we knew that we will change the interface here and there. If you want to upgrade then just go through your code and change those few things you have to change! Or don’t upgrade. (I’ll not go on about the whole myth of compatiblity and how often it is not completely true.)

That’s why we decided to release version 1.0 quite soon (December 2008, we started the project in August 2008) and find out what is missing. Version 2.0 followed quite quickly – in January 2009 we had the first alpha (quite stable though) and we decided to focus solely on this without any support for 1.0. The reason was that the Stopwatch behaviour changed quite a lot – for the better.

In 1.0 HalloWorld looked something like this:

SimonStopwatch stopwatch = SimonFactory.getStopwatch("org.javasimon.HelloWorld-stopwatch");
stopwatch.start();
System.out.println("Hello world, " + stopwatch);
stopwatch.stop();
System.out.println("Result: " + stopwatch);

Most important feature was that both start and stop were called on the Stopwatch. Now you may wonder what would happen if you started stopwatch twice and stopped it twice as well. It depended… though – honestly – I don’t remember exactly. Stopwatch had thread-local variable that remembered start timestamp (nanoseconds of course) and stop was expected to be called in the same thread. Double start and stop was illegal operation. Now this implied two serious limitations. The first was potential memory leak on the thread-local variable if you (client programmer) failed (or forgot) to stop the stopwatch. The second was that you couldn’t stop the stopwatch in a different thread.

This was troublesome design and happened to be resolved soon after 1.0 release. Our new HelloWorld looked (and still looks) like this:

Stopwatch stopwatch = SimonManager.getStopwatch("org.javasimon.examples.HelloWorld-stopwatch");
Split split = stopwatch.start();
System.out.println("Hello world, " + stopwatch);
split.stop();
System.out.println("Result: " + stopwatch);

Now the client programmer is fully responsible for working with the Split, there is no thread-local and the worst thing that may happen to the stopwatch is that its “actual” count will go up and up (and so indicate some problem with missing stops). Split will be garbage collected – unless stored by the programmer (his fault anyway ).

Another important features coming with 2.0 were JMX support (MX Bean) and Callbacks – these allowed programmer to hook on various events. But more about these in my next post, right?

JAMon guys used Jarep to store and graph results and what I liked the most was the story how these results available over a long time helped them when they needed it. Story went something like: “We found out that the performance of our web-shop started to be unacceptable sooner then originally calculated. Graph showed us that there was sudden jump half a year ago and since then the application performed worse. Luckily we had also work plan from IT stuff that revealed that the same day new JDBC driver was installed – and that was the reason.” Bottom line – without data you just don’t know. I liked that and it went pretty much along the lines Kirk Pepperdine says all the time – you need proof, you need data, you just need to know – don’t guess. Actually most wise people say that, but I remember Kirk and also that JAMon/JARep story when it comes to performance and monitoring.

A colleague of mine tried to use JAMon for our work project but he was not happy about the API. He was missing some management hierarchy – and that’s how idea of a tree hierarchy (not much different from java.util.logging for instance) for Simons started. Another issue was timer based on ms (JAMon is compatible with J2SE 1.4), I didn’t like that at all. So many things may happen in a single ms – not to mention most Windows changed the timer ever 10 or 16 ms. We decided to write our stopwatch facility and over one August weekend I wrote some basics (our first commits) and we started building on it. We can’t measure anything – like JAMon tries – we focused solely on Stopwatch and Counter. Three years later I’m happy about it – Stopwatch being probably 90% (or more) of all used Simons. Originally I wanted to give our users some way to add another kinds of Simons, but soon I realized how messy it would all become.

JAMon was in version 2.7 when we started the Simon project and the page looked exactly how it looks right now. We finished the first version in December, we were happy about most of it, we cared for the code and for the Javadoc too – and I think it was really obvious from the look at the project. These are ideas we still care for and quality Javadoc is undisputed part of the project.

TSS press release: Java Simon 1.0, monitoring API, released

Simon gained some initial attention and one particular developer even blogged a few times about us – check Evaluating Simon – Java monitoring or other Erik’s posts related to monitoring. Funny – later I’ve heard the name Erik van Oosten mentioned by my colleagues working with Wicket, but I’m 2 years ahead of the story. That’s just how it is with active people. His posts were most appreciated and he also provided AOP based Spring integration. Now – years later – even I use it in our current project (though it went through a few fixes, but the code is essentially still Erik’s).

Soon we discovered that the first version had a few serious issues and redesign was necessary. But more about that in the next installment some other time.

But this Friday one of the developers came back to me and said “hey, I do it so it is more readable”. And readable is the word I hear to pretty strong. I have no problem to read both these styles and I prefer the minimal one. While I’m clearly decided about comparing to true (utter waste and nicely exaggerated here), comparing to false is indeed a bit different. There you can argue that that exclamation is not always so visible.

It’s not always as easy as “short is better” – often on the contrary. Prominent example being the assignment in the middle of the expression – in a ternary expression for instance. I’d go for ifs and an assignment per line all the time. But while here we are mostly aligned when it comes to (checked == false) versus (!checked) we developers are not so unanimous.

The aforementioned link to stackoverflow inspired me to check how various cases are compiled. I made a class:

public class BooleanEqualityTest {
   boolean bb;

   private void a() {
       boolean b = bb;
   }
   private void b() {
       boolean b = bb == true;
   }
   private void c() {
       boolean b = (bb == true) == true;
   }
   private void x() {
       boolean b = !bb;
   }
   private void y() {
       boolean b = bb == false;
   }
   private void z() {
       boolean b = bb == false == false;
   }
}

After compile I went to the output directory and ran the command:

javap -private -c BooleanEqualityTest

And the result was:

Compiled from "BooleanEqualityTest.java"
public class BooleanEqualityTest extends java.lang.Object{
boolean bb;

public BooleanEqualityTest();
 Code:
  0:    aload_0
  1:    invokespecial    #1; //Method java/lang/Object."<init>":()V
  4:    return

private void a();
 Code:
  0:    aload_0
  1:    getfield    #2; //Field bb:Z
  4:    istore_1
  5:    return

private void b();
 Code:
  0:    aload_0
  1:    getfield    #2; //Field bb:Z
  4:    iconst_1
  5:    if_icmpne    12
  8:    iconst_1
  9:    goto    13
  12:    iconst_0
  13:    istore_1
  14:    return

private void c();
 Code:
  0:    aload_0
  1:    getfield    #2; //Field bb:Z
  4:    iconst_1
  5:    if_icmpne    12
  8:    iconst_1
  9:    goto    13
  12:    iconst_0
  13:    iconst_1
  14:    if_icmpne    21
  17:    iconst_1
  18:    goto    22
  21:    iconst_0
  22:    istore_1
  23:    return

private void x();
 Code:
  0:    aload_0
  1:    getfield    #2; //Field bb:Z
  4:    ifne    11
  7:    iconst_1
  8:    goto    12
  11:    iconst_0
  12:    istore_1
  13:    return

private void y();
 Code:
  0:    aload_0
  1:    getfield    #2; //Field bb:Z
  4:    ifne    11
  7:    iconst_1
  8:    goto    12
  11:    iconst_0
  12:    istore_1
  13:    return

private void z();
 Code:
  0:    aload_0
  1:    getfield    #2; //Field bb:Z
  4:    ifne    11
  7:    iconst_1
  8:    goto    12
  11:    iconst_0
  12:    ifne    19
  15:    iconst_1
  16:    goto    20
  19:    iconst_0
  20:    istore_1
  21:    return

}

What does it mean? Every == true is adding something to the code, but the first == false produces the same bytecode as the not operator itself (!). Every other == false is then adding to the code just like any other comparison. While HotSpot may do wonders with the code later I still consider it a waste and completely unnecessary – except for the single == false – and that was the case where I hesitated just a bit.

Now I will probably stop correcting this case, though I will keep writing !checked instead of checked == false. The only thing I don’t like about it all right now is that the inspection in IDEA cannot be set to ignore just this case. I can still set it to weak-warning, but that’s just not the same, you know.

What is your opinion on this matter? Do you have similar cases where you’re just not convinced which way is the cleaner one?

Update 31.10.2011: I decided after all. I’ll go for !(…) like this:

if (!(checked)) ...

We got it after all. We partially mavenized our projects (without using Maven while possible and hell, how easy was our life even with all those libraries we had to manage!), we split artifacts into their respective modules and we felt… well, reformed. Thank you.

With every version you brought refactorings that made sense and helped, templates that were really useful, and your completion… it was just all so normal and obvious until any of us had to use those other incompetent IDEs around. Where, tell me, where would we go? We’re not masochists, we know why we use you, it’s hardly possible to live without you anymore.

I declare here and now – I DO love you. You know it, I know it, everybody who knows me knows it – why to hide it anymore? I don’t care what my “normal” friends say (those that are not programmers, you know), I don’t care what people kept in the dark (you know, those living in umbra) may think, they never got it anyway what it is like when enum literals are just completed and foreach template asks for the collection first and the rest is just derived correctly.

My wife can hardly bear it, she’s jealous, but I just don’t care! I love you. But…

There are those times when it’s harder then it should be. Consider, my dear, just a few things. I did my part, I reported stuff, I was faithful – and I’d love to stay it that way. But there are things that are hard to forgive. Hard to go around. Sometimes I just have to use Eclipse – not because I want, not even because the project requires me to do so – but because you are so stubborn and can’t get better with just a few things. While Eclipse is just beyond any chance to be mended, you, my dear, have just a few bugs that are – I’m sure! – easy to fix and all those problems would be gone! All those little situations when Eclipse crowd can just laugh back for all my laughing on their pathetic SVN, Maven (or whatever you name) support.

Not that my list is short, but then there is clear line between things I can easily forgive (though not forget, you know how it goes after many years in relationships) and those I can’t however hard I try. You know that search widget introduced years ago… it would be just so good if Enter worked like in Firefox and Escape really cancelled the search and forgot whatever I wrote in there. No, you’re stubborn. But OK, however stupid it is, maybe all other users love your way and not the Firefox way. I can forgive this.

What I can’t, you ask? Well… the first thing is caused by the existence of Eclipse. You know, we store our resources with Unicode escapes – that is using transparent native-to-ASCII conversion. And the problem is that you and Eclipse just can’t agree on the same casing of those escape sequences. My dear, my dear, I know… it may be Eclipses fault too, but as pointed here, you are not in line with native2ascii tool in the first place. This bug might actually be close to some resolution IF… there wasn’t that resistant bug that appears in a few variants and prevents us from changing the file encoding. Quite serious, don’t you think?

Well, this I had on my heart today (and actually for many days, weeks, even months) and I just needed to get it out. I hope you’ll not take it the wrong way. I told you about my feelings and those are true. Yet I think love is not about being blind, you know. Whatever romantics may say. Of course, my nitpicking list could go longer, but let’s separate serious stuff from details, shall we…

And yes, I don’t want to repeat myself… but if I must. I love you. Of course.

• I knew Sparx Enterprise Architect a bit already and wanted to try something new (plus the lowest edition price was a bit lower),
• outputs look really nice compared to free alternatives (just like Sparx does, and both produce way nicer diagrams than Rational),
• I tried VP before (a few years actually), it impressed me then, and it impressed me the second time again.

I went for the Modeler Edition as I needed mostly just diagrams and nothing sophisticated behind. It all started with a bit of communication with the company about their one year support policy (simply put, without support you can get fixes, but no version upgrade, if I understand it correctly) and after that I bought one license with one-year support plan.

When I started to draw class diagrams I was satisfied with overall quality (as expected) but some features were surprisingly… well… indigested. It seemed to me like no user before me ever tried to work with gradient fills before. My creed is “nothing changes if nothing is said”, so I went on their support page and told them. There is no Jira-like open bug-tracking, but support is responsive and deals with your problems mostly in a matter of days – and I had a few more issues with my naive approach to diagrams, trust me. And all of them were solved to my satisfaction. Whow, really – for a company that has such an non-transparent issue tracking (for other users) I’d hardly expect score to be so great.

I was very happy about class, state machine and activity diagrams – though in case of activity I rather don’t like the UML notation. However I was less happy about object diagrams because it was rather complicated to get some attributes with specified values in it (far harder than adding an attribute in class diagram). Here you have to dive into dialogs and the VP magic is suddenly over. Also I didn’t like one thing about sequence diagram – I wanted to model interaction between an instance of a class – but I was not able to create life-line with just the type name (or turn of the name of the type, or something similar). In the end I rather created life-life with names I wanted (often the same as types) without actually using the existing type from the model. Maybe UML problem rather than VP’s – I don’t know – but I just didn’t want to have life-line boxes SO wide.

Apropos, so wide… all boxes have auto-size icon (bottom right corner), but when you write a long note, it wants to make it one line and extra wide. Also note text never goes under the curled corner rendering part of the box useless and always empty. And positioning of some elements is rather funny when you use grid – I had two associations between the same two classes and I wasn’t able to align cardinality number equally on both of them (to line or column, whatever the direction was). Alignment of these texts (association name, cardinality, …) somehow depends on the overall box size instead of text’s baseline. And it’s also not very easy to understand presentation settings and their defaults because some of them are checkboxes in contextual menu of the diagram (this menu is quite deep sometimes and after every change you have to open it again to switch another checkbox), but others are just actions. For instance turning off names of the association end (I display both association and attribute – and attribute is the name of the association role at the particular end) as a preferred behavior is done somewhere else (Tools/Options, but not diagram contextual menu).

And I also don’t like all the clutter in the Model explorer – this view is bloated by too many associations for instance – and you can’t tell which one is which, because it’s not so easy to find usages and show them right on the diagram (or maybe it is, but I remember doing this in Sparx EA much easier without checking the manual).

All in all, I’m happy using this software, but I didn’t realise one serious limitation. Modeler Edition is not limited only on features, but you can’t use it for commercial activity. Not even as a single person when you own it. And that is very serious limitation and suddenly makes the price too high. For just a few more bucks you can go for Enterprise Architect Desktop edition – I’m not aware of any such limitation there. And quality wise you probably don’t loose any bit.

Soon our company will evaluate where to go with our choice of UML tool – I hope for our sake we will leave Rational and use something that cares about actual usability – and Sparx EA is quite a hot candidate. Visual Paradigm seems to be very solid too, but there are less references around us, less actual users. I can use my license forever now (at least it’s perpetual) but only for some other (non-commercial) activity. Happens when you don’t read licenses properly.

Now I’m reading (among too many other things) Spring in Action – and there is that first chapter with Knight and Quest and how you can send Knight for a Quest using dependency injection. But who would do that? Now I was thinking: “Is it possible to manage runtime relations with Spring? Can I control entity creation and inject something to them?” What a stupid questions these are when you know what Spring really is, right? But why they are using Knight and Quest? Who would ever create a system with a knight (or a few of them) and *configure* them and their quests with Spring? Obviously – nobody.

And just this evening I was checking presentations from one local Oracle conference and professional Java Developer Advocate was explaining CDI and ManagedBeans with one SpaceCapsule and a Cosmonaut who’s ManagedBean was named “yuri”. How real is such an example? It’s not! It’s misleading altogether and that’s what is likely shown to CDI/DI/IoC newbie nowadays! I just can’t understand why…

Of course, we all play some little games with our code here and there, but I’d expect from new technology introduction also the right way how to use it. What type of situations, when yes and not. I don’t want them to suggest (or just accidentally imply) that I can manage various cosmonauts in my system in CDI – because that’s just wrong. I can name roles for managed beans, what they should act like in this and that scope… but “yuri”? Come on. Stop it. Please.

Or do you, readers, think this is the good way? Maybe it is, I don’t know. Sometimes I’m just off the crowd, really – and not always the right time. If you feel it some other way, drop me a line in comments.

Actually, talking about releasing artifact… right know I’m reading book about Continuous delivery (of software, of course), we’re still long way to get there all the way, but what strikes me is how often automation is mentioned and stressed. And here we are releasing Maven artifacts after reading dozens of points, installing external software (PGP), configuring tons of stuff and eventually failing in many cases (or just giving up). That’s definitely the biggest failure of Maven in my eyes.

But back to the title! Today it’s positive and – shame on me! – here I am spoiling it with all the reiteration of my previous concerns. So what is it that I suddenly like so much about Maven? It’s actually very simple. One thing that Maven really made right was imposing all its rules about project structure on us. Most of our current projects are not really Eclipse anymore, they are Maven projects – and Eclipse understands them, creates all is necessary files – but we don’t check in those.

While Eclipse project is not particular problem for my beloved IntelliJ IDEA (the same I cannot say about Eclipse… well talking about Idea’s project, not Eclipse’s own, of course ), using Maven projects in IDEA is just trivial too! And this kind of cooperation is just worth it. Because with Maven, you can go either direction. I just wish the building and all was just as pleasant as is project management.

This gives me opportunity to recheck some features I collected in previous months and haven’t published yet, though I don’t expect some big improvements in Eclipse core features (not sure why, but when I think about it like this, big blue logo always appears somewhere in my mind – I’m not sure how much IBM is to be blamed, really).

One big thing I don’t like about Eclipse is SVN integration – and I honestly don’t know how can anyone compare and criticize SVN in IDEA. While I don’t know about Synchronization feature in IDEA, truth is I never needed it! IDEA’s workflow is more in line with SVN – especially when it comes to adding files to the repository (before you actually commit them).

Another and probably more important thing is merging. In IDEA I’ve never been afraid of version conflicts – at least not technically. Conflict should be about decision making, but with Eclipse it’s a real nightmare instead. Most Eclipse users don’t know what 3-way diff is, there is no way how I can see my version, after-merge version (the result) and incoming version on one screen. This way you can always compare your code with the resulting code, you can move changes from your code to the result, etc. In Eclipse you can only change your code directly – and hardly see the differences in the end. I often close Eclipse and start Idea on the same project just to resolve conflicts and do commits.

Also files that can be merged perfectly are reported as in-conflict, because two (or more) people were working on them – this is ridiculous! Eclipse is confusing reporting conflicts, it’s also confusing about files added locally to repository. You have little control over it as new file is again and again suggested as an outgoing change (so you are forced to use SVN ignore, information that is stored in repository, to solve Eclipse’s own problems) – instead of you being in control and deciding whether the file is in revision control or not. You can add it, but there is no difference.

Let’s compare some refactorings, completion and shortcuts again!

You can easily do basic refactorings on classes in IDEA – shortcuts are familiar from Norton/TotalCommander (F5 copy, Shift+F5 clone, F6 move, Shift+F6 rename). This works consistently whether you are in editor with cursor on the class name or in the project tree. In Eclipse you have to go to the project tree and do it there. Clone/copy is Ctrl+C and Ctrl+V, not sure if that is refactoring. F2 in Eclipse works in project tree, on the class name in the editor you have to use Alt+Shift+R.

Ctrl+Space is the same, but in Eclipse many other features are bound to the same “completion” functionality while in IDEA you have the following: Ctrl+O (override), Ctrl+I (implements), Alt+Insert (toString, setters/getters – but if you want more than just one of them use Alt+S, R in Eclipse rather than Ctrl+Space – or bind it to your key somehow) – and of course also IDEA’s smart completion Ctrl+Shift+Space. Here – while it may seem stupid to have so many keys in IDEA for every different thing I never had problem with that (because you always know what to do). Also the lists are more focused for various functions while in Eclipse it’s all in one list. The rest is probably just the matter of taste. However, smart completion (Ctrl+Shift+Space) from Idea works much better for me than Eclipse’s all-embracing completion. Not to mention Eclipse doesn’t offer enum value completion in method parameters or equals as IDEA naturally does.

Class name completion in non-java files – IDEA is far superior compared to virtually no completion in (for instance) XML files in Eclipse (may vary in Java EE version).

God/Devil is in the details when it comes to how to accept the completion. In Idea you can press Tab or Enter. The difference is when you “overwrite” some existing code, identifier, value, whatever. Tab is natural for us, Idea crowd, and it replaces the previous stuff. I made the test, check this animated GIF – funny that Enter behavior differs with and without smart completion (Ctrl+Space vs. Ctrl+Shift+Space) – but as it’s mostly not what you want, it doesn’t really matter, right? Eclipse behavior is different when finishing enum and the class (animated GIF, in 3rd case it does what it should, ignore the syntax error) – to simplify things one can say that Ctrl+Enter is always what you want (probably). Many users may not know about the difference or haven’t thought about it, but it indeed is a difference. Here “know your IDE” is the most important thing – then you can get what you want quickly in both.

Eclipse’s Ctrl+Space has one additional feature – when you press it repeatedly it cycles through a few filtered views (Template Proposals, SWT Template Proposals, JPA Proposals) – this can be further customized in Preferences/Java/Editor/Content Assist/Advanced.

Finally – here are two IDEA-positive resources – about IDEA knowing what you want (there are more articles in the same month) and one quite an active blog.

Don’t miss other posts on this topic:
Eclipse vs IntelliJ IDEA
From IntelliJ IDEA to Eclipse (2)
Why to synchronize with SVN in Eclipse?
From IntelliJ IDEA to Eclipse (3)
From IntelliJ IDEA to Eclipse (4)

What I want – some class diagram to model my entities (ER diagram will be done in Oracle SQL Developer Data Modeler, that is set in our team), some enums, state machines for enums (some of them are state values) and some sequence diagram here and there. Nothing big, nothing MDD.

In our company we use IBM Rational Software Modeler 7.5.4. I can’t say how it looks in newer versions, but this one is just killing me with it’s “hey! I’m built on Eclipse platform!” approach. I created model for instance, and I went for some design template that I felt is best for me. Alas, the template didn’t have state machine diagram. Can you add it somehow? I don’t know, there is no obvious way? Can you google how? I don’t know, it seems that IBM/Rational did the best job in anti-SEO. Their documentation is most difficult to find with search engines, and kinda… IBMish. I created new model without template and copied my old model into that one – what a fix. Even if there is way how to add diagram that is not in template (there always should be!) or how to convert model to another template – these functions are not easy to find. That’s like they are not there.

And the UI itself – it’s massive click-fest with minimum keyboard shortcuts (how I love IDEA, because it always tells you in pop-up menus what the shortcut is). Results are quite OK, if you know how to export them. Default export dialog is just another Eclipse-style hell, the same goes for import, you know one expects import where you just specify the file and it’s imported, but in Rational it’s always difficult – you have to know dozen of steps to do before the actual import. Eclipse based software traditionally has very poor consistency between contextual menus. You have File, Save As Image File… on right click in the diagram itself, but you don’t have it when you right click the diagram node in Project Explorer, nor you have it in main menu in any expected place. I honestly admire bravery of all those working with this tool.

I tried some other free: ArgoUML (limited UML 2 and undo support, plus I just didn’t like it), StarUML (not in development anymore… since 2005) and finally astah* community. Astah is probably my favourite choice from those freely available, though its community version has some serious limitations (enums are just ugly if you don’t use professional edition). But it’s much more intuitive than Rational, workflow is much better (well, there is hardly any “flow” in Rational, really) and I will probably use it in my future works.

Then there is one option for non-commercial usage (which means no option for me) – Visual Paradigm, or rather their VP for UML. Their suite (5.2) contains UML modeller (8.2) that is quite usable for drawing, but you’ll suffer quite aggressive watermark if you create more than one diagram per type. This actually means I’d not use it for non-commercial project either – unless I don’t need image outputs (which I mostly want to have). But the price for modeler edition is quite reasonable ($99) and in overall work with VP for UML was OK. By default their diagrams have rather simple visuals (no gradients so popular today), but they look clean on paper and – the most important – there are enough features that are easy to use (with keyboard shortcuts too ).

And finally, tool I like most of them – Enterprise Architect. Here I have to say that I worked with this tool. I never liked drawing diagrams (mostly because of the tools itself), but this one makes it quite easy. You have to get used to it’s dialog window workflow, but everything is accessible and resulting diagrams are just nice and clean. Desktop Edition starts at $135 and I think it’s well worth it.

One thing I particularly liked about EA is that it allowed me to bind associations to attributes, so you could see both lines (associations) and attributes in the class. I like attributes as a kind of checklist, without need to go around the box and search for associations – and I don’t care if it’s UMLish or not. EA allows this and I just love it.

One thing I couldn’t model as I’d wish to – I have enum and I want its literals to be states in state machine diagram. I don’t know how to do this in any of these tools. Right now I have to repeat myself and add states with the same names as literals in the enum.

After all this, my winners are astah* for being free and EA if one is willing to spend $135. I think for companies it’s definitely much better investment than Rational if you care for sanity of your staff.

I can’t tell how these tools work for more developers, how easy is to keep their project files in SVN, or how you like them after a year or two – or which one causes the most serious RSI. That’s why it’s called skimming after all.

And we all know where we are now. Maybe, just maybe HTML5 will push things somehow and browsers will converge a bit – I don’t expect complete compatibility anytime soon. Just maybe.

Today my colleague committed a few Java files that couldn’t be compiled because of the compiler error:

illegal character: \65279

I quickly found out about UTF-8 and BOM (more here), there is even bug related to this – it’s funny to read ironic comments about “bug compatibility” too. After more searching I decided that our sources must not have BOM, even though that it seems it could be there (by Unicode specification) and I’d expect javac to compile it all. My colleagues compiler even did it (maybe some Jikes in Eclipse or what, not sure), but other colleagues experienced “my problem” too. BOM itself was probably introduced by some clever editor.

Now how to get rid of it easily – it was only in 5 files, some hexa editor would help. It has been some time since I installed Notepad2 on my system. Well, installed… I replaced original notepad.exe by this one. This way Total Commander opens it without any setup. Notepad2 doesn’t have hexa editor, that’s true, but I noticed that it shows “UTF-8 Signature” in status bar. So I clicked there, changed it to “Unicode (UTF-8)” (without Signature) – and that was it!

Now – Notepad2 is far from the only solution here, but I mentioned it because it was a nice surprise how easy and straightforward it was and because it’s just so lovely Notepad, that I really recommend anyone to remove original notepad.exe (quite a pain with all the needed permission messing) and install this one. It’s not replacement for your Crimson or PSPad or whatever, but whenever Windows tries to show you true power of its default Notepad, you’ll be glad you followed my advice. Trust me.

And seeing things like Notepad2, things that are simple and really work, I often find my positive way again and my faith is restored and I can go on to another endless battle with yet another technological stupidity. May that force be with you as well.

While Idea has static Default Keymap Reference in its Help menu, Eclipse has Key Assist (Ctrl+Shift+L) – which is more handy if you don’t know what you’re looking for (name of the features are not always the same between both products). Idea’s Search Action (Ctrl+Shift+A) can compensate for this. Talking about Help menu – you can check some JetBrains TV videos about IDEA to get better idea how to be productive or just for some tips.

There is Idea keymap for Eclipse (plugin), but I wasn’t satisfied with it’s completeness, plus I wasn’t happy with Idea shortcut acting the Eclipse way – and you can’t change that. And I also want to be able use Eclipse on colleague’s computers too – so why not to learn it with its shortcuts? Well…

One recommendation actually – duplicate (called copy line in Eclipse) and delete line – you may want to change those. You can mostly live with rest (yes even with Enter vs Tab to confirm completion) but Ctrl+D will soon kill you, especially if you are forced to work in Eclipse more than you can in Idea. I changed it in the Default scheme, because when I wanted to create a new one, I found out it’s not possible in any simple way.

Shortcut Schemes cannot be copied inside of Eclipse. If you’re wondering how to create a new one, wonder no more – you have to do it this way (not that I understand that page too much). I’m also not sure how you can add more binds to one action (not a sequence, but two different combinations). Long way to catch Idea on this one.

OK, and now some “Idea-Eclipse remapping” right?

• Alt+Enter is Ctrl+1 – called quick fix
• Ctrl+H is F4 – view type hierarchy
• Ctrl+B or F4 is F3 (Ctrl+left click works the same, though a bit lazily – you have to wait till Eclipse underlines the stuff – maybe even move the cursor a bit, sometimes I can’t force Eclipse to understand this) – you’ll probably mess F3 with F4 a bit
• F3, Shift+F3 is Ctrl+K and Ctrl+Shift+K – next/previous search, in Eclipse you can just select stuff and press Ctrl+K, in Idea you have to Ctrl+F it or highlight it with Ctrl+Shift+F7, then F3
• F2, Shift+F2 is Ctrl+. and Ctrl+, – next/previous error/warning, in both IDEs you can set to focus on errors first instead of mixing warnings in too – in Eclipse go to Preferences, General, Editors, Text Editors, Annotations and there you can include many things into this kind of search
• Ctrl+Y is Ctrl+D – what a shock for delete a line
• Ctrl+D is Ctrl+Alt+Down/Up (but only for whole lines) – now you see why I recommend to switch at least this, Eclipse’s option to copy up or down is quite nice, though minor feature
• Ctrl+W/Ctrl+Shift+W is Alt+Shift+Up/Down – but the selection jumps differently than in Idea and you will probably not like it at all, in Idea it really starts with word – even inside of strings, but not in Eclipse; funny enough, while word selection is way too eager in Eclipse, Ctrl+Left/Right jumps to camel humps inside words (which in most cases is too slow for me, but YMMV of course, you can switch it in Preferences); you will also probably hate selection expansion on property names, where I want to start with one word again, not the whole property
• Eclipse has Ctrl+J for incremental search – this is mostly similar to Ctrl+F in Idea, though Idea’s Enter/Escape workflow in the search bar could be better for smoother feel (but maybe nobody feels the same)
• Ctrl+G is Ctrl+L – go to line
• Ctrl+Alt+V (as variable) is Alt+Shift+L (as local)
• Ctrl+Alt+C (constant) is only in menu – Alt-T (T as refactor ) and there press A (as … well, constant). This leads us to menu mnemonics. Maybe in Eclipse they are problematic because of some history (that is shorter than Idea, BTW), I don’t know. But however you look at it, refactor is not so important, so intuitive, you have to remember strange shortcuts or add your own (which means changes to the Default key scheme for most normal users)
• Instead of File Structure View (Ctrl+F12) you have Outline (Ctrl+O) in Eclipse. While in outline you can lookup any member from nested classes (something I suggested for Idea a few days back) you can’t use camel humps lookup (gF for getFilter for instance)
• Ctrl+N is Ctrl+Shift+T to find class quickly – camel humps work nicely in both
• Ctrl+Shift+N is Ctrl+Shift+R to find any resource (file)

Find in path (Idea’s Ctrl+Shift+F) is quite a pain really. There is no item for this in context menu on the project tree, you have to select the directory, go to menu Search and select File… I don’t feel like searching for file, I take it more like searching for occurrences, but whatever. After this you have to switch radio button to “Selected resources” (I honestly wouldn’t understand that without help, though directory is kinda resource too, right?) and there you go finally. Many Eclipse users don’t know what that radio button means and they rather go with working sets or just change pattern for files if possible. Very, very non-intuitive.

Find usages (Alt+F7) is here (Ctrl+H) but funny enough my Eclipse mates wondered why I ask if I can see the actual lines with occurrence in the search results. Maybe just to know how the same method was used without going to the source! I’m sure we (Idea users) miss some funny features from Eclipse too and we don’t know about them yet. Sometimes I’m in doubt if we all code in Java really – so many mindset differences. Also be aware that Eclipse might open all your search results in a single tab – you can change this in Preferences. Also the behavior of this find is very annoying. In non-java files it mostly offers File Search (text search) tab as default, but in Java it offers Java Search with File Search tab missing altogether. That’s the famous “context-awareness” of Eclipse in its worst moments, if you ask me.

Comment the line (Ctrl+/ in both IDEs) works in Java but not in XML/HTML/CSS [EDIT: reportedly it does for JavaEE version]. (CSS doesn’t work in Idea Community Edition either, but then – CSS syntax is officially not supported there.)

Alt+Shift+Insert for column selection mode is Alt+Shift+A. No problem with selection behavior either.

Open recently closed editors with Ctrl+E? Depends… there is no list of files recently closed (quite a shame if you ask me), but you can quickly reopen the last one using Ctrl+Q (last edit location) or hope that your recently closed tab was one of those recently open and then you can use Alt+F and some number (default last 4 can be changed to 9, I strongly recommend that if you need it in your workflow). This is feature I really miss in Eclipse – and from what I asked, many Eclipse users too.

Finally two more links:

• Essential Eclipse Shortcuts (in line with today’s post)
• And some tips for new Eclipse users

I have a bunch of other things prepared, completion comparison mostly with some animated gifs, so stay tuned!

Don’t miss other posts on this topic:
Eclipse vs IntelliJ IDEA
From IntelliJ IDEA to Eclipse (2)
Why to synchronize with SVN in Eclipse?
From IntelliJ IDEA to Eclipse (3)
From IntelliJ IDEA to Eclipse (5)