During the first month of Forza Motorsport 2 online gaming, one of my new online friends I met in the public lobbies tuned one of my cars for me. Wow, what a difference that was compared to the not tuned car. It handled much better and was faster, too. Armed with the knowledge that tuned cars can have better handling and can be faster, I tried tuning some of my other cars myself. Hmm, was much more difficult than I had thought. Most of it was trial and error, and I got tired fast.

But I really wanted my cars to be and behave better. So I turned to the theory necessary to understand what was needed to be successful with that. It was complicated, and although I understood the interaction of the various settings better, the quality of the results was only slightly better than before.

And then, I found FEUERDOGs suspension calculator for Forza Motorsport 2. The settings it produced were much better than those of my own efforts. And to be honest, I wanted to race. You have to like tuning in order to like it – haha! It’s not my thing. But by trying to tune cars in Forza Motorsport 2 myself, I got a glimpse of what it means to become a successful tuner.

Then came Forza Motorsport 3, and I was eager to get it. I used the same tuning calculator for the new version of the game, and it still produced better tuning setups than I was able to come up with myself. FEUERDOG started working on a version for Forza Motorsport 3 and eventually he released it to the public.

I have no idea how many hours FEUERDOG spent to create the tuning calculators he did create. He might have spend more hours on it than I was spending on racing. Maybe he had as much fun doing the tuning calculator as I had during racing. But his work alone made it much more fun for me.

So today, I’m releasing ForzaDroid, the implementation of FEUERDOGs tuning calculator FM3-December Update-4 as an Android application on the Android market for free. There can be no other way, because I’m standing on the shoulders of giants here.

What does it offer? Well, here’s a list:

• based entirely on FEUERDOGs FM3-December Update-4 spreadsheet, you’ll get the same results
• added “Transmission” selection for RWD differential settings (see FEUERDOGs remark in the spreadsheet for details)
• available in English and German
• it’s available at the Android Market and free (as in beer)
• it’s simple and fast (hey, I’m not a designer, I’m a programmer)
• no gear spreader – yet

To download ForzaDroid, visit the Android Market and search for it (search term forzadroid, but forza might work as well), or just scan the following QR Code with your Android powered mobile phone. It will take you directly to the Android Market:

If you have never tuned a car in Forza Motorsport 3 before, you can head over to ForzaTune were you can find more information. They’re offering an iPhone application that does roughly the same thing – even more, it supports Forza Motorsport 2 – as ForzaDroid. It’s also based on FEUERDOGs work. But it has been around much longer.

If you like the Android application ForzaDroid, find a bug or have some suggestions, feel free to contact me. I won’t promise anything, but at least I’ll listen.

During the recent holidays I spent the entire time away from work and with my family. As most of the time when I’m away from work I made a list of things to look at. Wicket was not on that list. I seldom make it at least half way thru that list anyway. It was the same this time. But then I saw this article on TheServerSide about the release of Wicket 1.3. The big amount of comments caught my interest. Suddenly, Wicket was on that list.

Today, I downloaded and installed Wicket, and then looked for documentation and tutorials. Besides some interesting online resources, I found the combination of two books on Wicket the most helpful:

• The first ten available chapters of Wicket in Action (MEAP – Manning Early Access Program) by Martijn Dashorst and Eelco Hillenius, published by Manning Publications Co.
• Enjoying Web Development with Wicket by Ka Iok Kent Tong, published as PDF only, with freely available first three chapters

The first book seems a little more verbose than the second book and covers more background, while the second book (besides being more complete right now) has much more source code examples. They complement each other perfectly in my opinion. So I got them both.

After reading thru the first three freely available chapters of “Enjoying Web Development with Wicket”, I got interested in chapter 6 (Supporting Other Languages). I was really impressed to see how I18N is a first class citizen in Wicket.

I then turned to “Wicket in Action”. Right now it is not completed and contains many errors, but none of this is really a problem. I made it thru the chapters 1-4 and implemented the Cheesr sample application (from chapter 4) along the way.

I really like what I’ve seen so far from Wicket:

• It’s component based and encapsulates the request/response cycle
• Components seem easy to write
• Good internationalisation concept
• Separation from logic and presentation

Right, I’ve barely scratched the surface yet, but Wicket as a web framework looks promising.

Three days after GWT 1.4.60 came out, the issue was reported, approximately at the same time I was experiencing it. I was hoping for a quick fix, but it didn’t come.

Several month later, Google’s Scott Blum wrote in the GWT forum about an updated GWT 1.4 release. Although I read the forum quite regularly, I nearly missed his posting. He talks about the new release fixing the problem, and he also provides a download link for GWT 1.4.61. I’ve downloaded it and upgraded all my application without a problem so far.

Since it fixes a very serious problem, you should upgrade also. Problem is, you will not see the new version on the GWT download page. At least not yet, but I bet you will see it there shortly. In the meantime, just use this link.

Update: It took a little bit longer than I expected, but the GWT Team has just officially released GWT 1.4.61, which takes care of some minor bugs in the previous release of GWT 1.4.60. The two main issues that were addressed are the “operation aborted” startup error on IE and a potential XSS vulnerability in hosted mode.

There are no differences between the 1.4.61 version released on December 12th, 2007 and the 1.4.61 version released on November 3rd, 2007.

If the application doesn’t load, please click here!

Before I was able to include a GWT application within a post in this WordPress powered blog, I had to create a WordPress plugin that generates the necessary meta tags. GWT applications only work, when those meta tags are present.

The actual calculation of the expression is done on the server with the help of my Java based framework. The expression is sent to the server asynchronously as a JSON data packet. The server logic evaluates the expression and sends back either the result, or an error message. If you want to see an error message, try a division by 0. The response is sent also in the JSON format back to the browser, where the GWT application takes it and displays it without refreshing the whole page.

The server side logic is built with the help of ANTLR and ANTLR Studio for Eclipse. Instead of writing a lexer and parser for evaluation of the expressions myself, I’ve used a grammar to let these tools do it for me. The following screenshot shows ANTLR Studio for Eclipse in action:

If you want to know what ANTLR is, here is a quote from Terence Parr, the primary author of ANTLR. He has been working on translation tools since the late 80s:

ANTLR, ANother Tool for Language Recognition, (formerly PCCTS) is a parser and translator generator tool, akin to the venerable lex/yacc duo, that lets you construct recognizers, compilers, and source-to-source translators from grammatical descriptions containing C++ or Java actions. You can build translators for database formats, graphical data files (e.g., PostScript, AutoCAD), text processing files (e.g., HTML, SGML), etc. ANTLR is designed to handle all of your translation tasks. ANTLR is recommended by the co-inventor of LL(k) parsers and by the inventor of SLR(k) and LALR(k) parser.

Another tool makes generation of GWT clients easier. It’s the GWT Designer from Instantiations. I’m having a few problems with it, but it still helps a lot. See the following screenshot for an impression:

If you’re interested in this example built with GWT, ANTLR, JSON, etc., and you want to look at the source code, just download it from here.

Do you remember the little problem from the Geometry for kids post earlier today? With the calculator, you can verify if the solution is correct: d = sqrt(3)*5.3.

Update 1: As of GWT 1.4, a new application-loading mechanism has been introduced, that doesn’t require a meta tag in the page header. It’s still supported for legacy applications. But now, the applications HTML code can directly reference the JavaScript file. I’ve changed the example above accordingly.

Update 2: The calculator has been updated to GWT 2.0. The project available for download has been updated as well.

I very much welcome this step by Google. But they need to do something else, too. As someone on Google Web Toolkit Online Group pointed out, Google needs to build a major application with GWT. And they need to do it soon. This will help everybody who has to make a decision for GWT that is not based on its technical merits alone.

I’ve started to use GWT since version 1.0 came out (August 25, 2006). It was easy to use and since I’m not very good at JavaScript programming, leave alone all the little things you have to know to make sure your JavaScript is compatible with all the different browsers, it was the right thing for me as a Java developer.

Integration with synformation is easy. I don’t use GWT’s RPC mechanism, but the JSON format for client-server communication. GWT finally supports sending requests with content-type application/x-www-form-urlencoded, which is how it’s normally done. On the server side, I can now use request.getParameter() instead of having to read the posted data directly. It’s really not a big deal, but more convenient. The new module com.google.gwt.http.HTTP provides the necessary functionality.

I’ve written a quick example. It’s available here. It sends formatting instructions to the server via JSON. The server formats the current time and sends the text back to the client. The relevant portion of the page is updated to display the current server time. Note that not the whole page is updated, only the text with the server time. That’s because client-server communication is done asynchronously in the background. Although it’s only a small example, it already has the complete communication architecture for RIAs.

Someone might ask: why does it make such a big difference to have most of Java under the GPL? To find the answer, you have to understand what the GPL is, what it gives you, and what you can do with it. What its intent is. What Richard Stallman wanted.