It's been two weeks since I ported Bla-bla List to the latest release of OpenLaszlo. I must say that many of my previous gripes have been resolved.

I'll revisit them quickly:

• Compilation time

  The LZX compiler is now written in plain Java instead of Jython, the compilation time really became much better and as soon you've done it once, further re-compilations are quite snappy.

• HTTP POST requests

  The previous bugs with it seem to be resolved, everything is working fine now. It would be handy though to be able to set the request type as an attribute of the dataset tag, instead of having to manually change it to POST each time you perform the request.

• Performance

  The resulting file is now targeted at Flash v6, which runs noticeably faster. The fact that most fonts can now be platform fonts and don't have to be embedded is also a nice bonus. This does however lead to a problem on some Linux installations since the Flash plugin mandates the presence of Microsoft's core fonts to fall back to. Ubuntu (and others) don't seem to install these, so when Flash's font fallback mechanism kicks in, the user sees no text at all. This is pretty annoying.

  I created a generic pane component class that I extend for every page. It defaults every page to late initialization and postpones resize events when the pane is not visible. This bumped up the performance quite a bit and the resizable interface is acceptably fast now, even on slower machine.

• Javascript and XPath support

  Not much has improved there and it would really be nice if they would try to aim for full XPath compliance. Javascript can now however be run outside of Flash, in the embedding browser, which means that you can use it for expensive calculations. I haven't done this myself, but some people on the mailing list seem to be doing this. It looks to me as an acceptable solution for Flash's slow Actionscript.

• Multi-line text editing

  After the 3.0b2 release, a Laszlo developer sent me one, and I modified it. I put the result on the forums and someone else made it even better. This component should imho be included in the core distribution. At least there's now one available that can directly be used.

• Databound items reset & full drag and drop

  These issues remain.

Apart from these I really dig a couple of other (new) things that made me appreciate Laszlo a lot more than before.

• Resizable canvas

  Any Laszlo application can now be resizable within the browser if you position your components relatively. I'm pleasantly surprised with the performance of this since I expected it to be unbearably slow.

  Sadly, the Flash plugin on Linux seems to have a bug that prevents the HTML object tag to be resized. You have to access the .swf directly instead.

• Serverless deployment

  This feature seriously rocks. I just set up a compilelaszlo ant task in my build file, and an swf is generated during the build process and packaged afterwards into the war. I can drop this web application into any servlet container without having to run the Laszlo proxy server.

  People also requested me to send them the Flash file separately so that they could run the application inside GMail and other web applications. This is a major step forward for Laszlo's adoption imho.

• LZX's component object model

  I feared that Laszlo would become very difficult to maintain, since everything is done in XML with embedded Javascript. However, when you structure your applications correctly by using classes and inheritance to avoid code duplication and work in an OO fashion, things become surprisingly maintainable. Everything is nicely isolated and making a change is quite intuitive.

  This object model pleased me particularly well since it behaves very similar to how we structured elements with our RIFE framework on the server-side.

For me, the main issue is still that Laszlo only targets the Flash runtime. The developers are however actively investigating other target platforms where Java (Applets) and DHTML (Ajax) are possible candidates. If you have suggestions or thoughts about this, sign up to the mailing lists and raise your voice, they really want to hear the open-source community talk and have you help them understand the needs better.

During the recent Rails slashdot post that refers to a blog post that once again manages to compare totally different application stacks and draw conclusions out of it, someone referenced the out-of-context micro code comparison that was done about Bla-bla List and casted once more a collection of unbacked criticisms.

I tried to clarify a few points and guess what, someone else (I guess Matt McRay, but he wasn't man enough to use a real name) just nicely summarized all the criticisms that I got about Bla-bla List from Rails users. Somehow they seem to feel hurt by the fact that I tried to show Java developers that Java can be concise too without lots of setup and configuration files.

This is the post with my in-lined answers. Since it'll probably get lost on slashdot and I want Java people to read them, I repeat it here. I love Java and the recent Rails buzz blows a lot of things totally out of proportion, I just want to blow back a bit:

Yes I did exactly what I said I'd do and a lot more. I keep having to explain things over and over again to you Rails activists, but you seem to be unable to understand anything that is only just slightly different from the concepts that you use.

So you're saying that you actually manage to look elsewhere than the src/templates directory? You look in the web directory instead and call .lzx Laszlo files, templates. Even though they have nothing to do with templates? They are a SEPARATE application, and everything in Bla-bla List can be done without it. Oh, and btw, Ta-da Lists's template line count was not taken into account into the 600 lines, so stop whining. Rails' templates contain logic and loops, RIFE's not. I actually included those loops in the line-count instead of leaving them out.

You guys continue to amaze me, so you write an even more simple to-do list with Rails that does some Ajax eye-candy and only does account management and list editing. Let's take a look about what's missing, will ya:

• no public sharing,
• no private sharing,
• no RSS,
• no item reordering,
• no list reordering,
• no different presentation of done lists,
• no 'nice shrinking/growing' icon,
• no list emailing,
• no automatic installation,
• ....

and you still manage to let it be a hefty 340 lines in your awesome concise framework? You just confirmed that you never take the time to check ANY of your statements and just troll on senselessly in the direction of whoever is leading you. SAD! Btw, I'd wouldn't call Bla-bla a RIFE-optimised application at all. Quite the contrary in fact, almost nothing is used of the important features of RIFE. The application is so simple that you never get to leverage any of the benefits since there's never any data flowing around. They are all single actions. I'd rather call Ta-da optimized for Rails since you have your List Act which does all the list handling automatically in the framework. We don't consider CRUD operations a core feature, but will soon release RIFE/crud as a separate package that addresses this without any code generation. Bla-bla List doesn't use any of that btw.

Which configuration? This is what you call configuration? I hate to bring it to you, but that is not configuration. It's separation and declaration of the application's logic and data flow which brings an enormous collection of features that you wouldn't even understand since you marvel at your pityful one-dimensional controllers. Once more, you seem to be totally deluded since I DID COUNT the lines of that file in the final line count. I checked before with my friend Brian McCallister, who knows Rails quite well, to see if I should include it. I'm still not that sure I should have since the features it gives you are completely impossible to do with Rails. If you're interested in that, start using a real name, be a man and we'll have some extensive chat about that elsewhere.

Oh, don't worry, I don't comment on your code with micro comparisons as Rails activists seem to love to do. I do comment on the fact that you only implemented 15% of the application and did none of the complicated stuff. /golfclap you just made a total jerk out of yourself.

Last time I checked, I didn't win the contest (since I came out 300 lines more). More even, I never did a contest since Ta-da's code is nowhere to be seen. All I did was show Java developers that Java can be concise and doesn't have to be totally convoluted.

Which rules did I set?

• I faithfully cloned Ta-da List even though the 'Edit list' part is very stupid and I'll probably re-do it in-line in the GUI.
• I used Laszlo to build a separated application which has nothing to do with the server-side and merely interfaces with the REST API and interpretes the results that are sent back. It's sad that you don't seem to understand that these results are just one way of presenting the data, in this case as XML instead of HTML + Javascript. If you can't make the mental switch that what you see in the Laszlo GUI is not what is generated by the view layer of the server-side application, then there's a painful future ahead of you with Ajax.
• I fixed a couple of issues with the application that I found important.
• I added a number of features that were missing according to me.

Please stop wasting my and other people's time with accusations that are totally unfounded and unresearched.