The problem in solving such a Serializable exception is finding the field that is not Serializable. The stacktrace of java doesn’t help much. Fortunatelly, after some searching I’ve found the solution, in the comment of blog posting: add the option -Dsun.io.serialization.extendedDebugInfo=true to the JVM startup parameters.
Now the stacktrace gives you the exact fieldname or expression that is causing the problems, as you can see in the example below:

2011-07-23 21:44:50,362 ERROR [http-8080-1] [] org.apache.wicket.util.lang.Objects - Error serializing object class nl.gerbrandict.forum.AdminPage [object=[Page class = nl.gerbrandict.forum.AdminPage, id = 2, version = 0]]
java.io.NotSerializableException: org.springframework.beans.factory.support.DefaultListableBeanFactory
- field (class "org.springframework.orm.hibernate3.HibernateTransactionManager", name: "beanFactory", type: "interface org.springframework.beans.factory.BeanFactory")
- object (class "org.springframework.orm.hibernate3.HibernateTransactionManager", org.springframework.orm.hibernate3.HibernateTransactionManager@10fd8ce3)
- custom writeObject data (class "org.springframework.transaction.interceptor.TransactionInterceptor")
- object (class "org.springframework.transaction.interceptor.TransactionInterceptor", org.springframework.transaction.interceptor.TransactionInterceptor@2c96cb51)
- field (class "org.springframework.transaction.interceptor.TransactionAttributeSourceAdvisor", name: "transactionInterceptor", type: "class org.springframework.transaction.interceptor.TransactionInterceptor")
..
        - field (class "nl.gerbrandict.forum.AdminModel", name: "person", type: "class nl.gerbrandict.forum.Person")

(note: not publishing the entire stack trace and using some sample dummy field/classnames).
Although I haven’t tried, enabling this option in production is most likely a bad idea, because Serialization is already a pretty inefficient process without any debugging information enabled. In my case, I was using a PropertyModel somewhere, using non model as target object.

Roger gave an overview of the new JavaFX 2.0, the road-map and the planned features. The software seems to be developed in an agile manner: the dead line is fixed, as is policy at Oracle (not meeting a dead line means exit for the responsible executive), but the final set of features is not.
The preview is available now for a limited audience, in May the first public beta will be released and in November the final will be available.

The most important news I heard:

• JavaFX 2.0 will be a library (jfx.jar), rather than a separate scripting language JavaFX. The language works in the language Java of course, but you can use the language Scala, JRuby, Jython or other languages available on the JVM. JavaFX script is end-of-life. Fortunately, the syntax of the library calls is quite similar, and there’s a program to translate JavaFX script into equivalent Javacode. Curiously, the translator, FX Translator, is written in Scala.
  Update 2011-06-15: I only heard about the fx translator at the here mentioned presentation. I could find little references to the translator: a back-reference to this posting (sigh) and the fxtranslator mentioned shortly in this posting on DrDobbs.
  If you want to use the FXtranslator, you’ll have to contact Oracle for now. I guess Oracle will release the automatic translation tool in some time too.
• The Swing-controls can be used from JavaFX 2.0. The ‘traditional Swing’ is now in maintenance mode, Oracle won’t create an new features for the original Swing library. Meaning, if you want to develop Swing applications, or more generally, desktop applications in Java now, you can best get the beta or coming GA of JavaFX.
• JavaFX 2.0 will be available on neither the Mobiles nor Televisions! Oracle has accepted (Sun’s) loss, and will only focus on the desktop for the time being.
  JavaFX seems practical on tablet-devices. However, since most tablet devices are enlarged mobiles (running a mobile os) ratter than flattened laptops (running a full desktop os), you can’t use JavaFX on any of those devices for the time being.
• The JavaFX is supported on the MS-Windows platform only for the coming time, (but) it will run on Mac, Linux or other platforms unsupported. This means, you might miss the hardware acceleration when not using Windows. Mind you: Roger was using a Mac while doing his presentation and demonstration the code-samples so the MS-Windows-only support might not look as dramatic as it seems at first glance.
• Of course JavaFX runs on the JVM 6 or higher. If all goes well, JavaFX will be part of JDK 8. Before that JavaFX can be downloaded as a plugin before from java.com, which will be not to painful for users, especially if they already have some version of the Java-plugin installed.

The JavaFX SDK contains a set of sample application called ‘Ensemble’. Roger presented a few impressive programs, and showed the source code. The audience, including the Oracle employee hosting the event was very tech oriented so everyone was eager to see the code of all the nice examples.

Furthermore, Roger frequently mentioned Podcasts. I have yet to listen to them, but maybe if I have some time left. Should find a way to broadcast audio while doing the dishes.
All in all a nice event. Oracle may turn JavaFX in something that might be practical and usable on a limited number of platforms, ratter then trying to take over the world (or more specifically taking on Android, Flex, Apple IOS).

As you might notice, I’ve got no code examples or screen-shots. I hope to get access to the beta release of JavaFX 2.0, I’m quite interested in trying out all those nifty things, and expect some nice blog postings on JavaFX soon!

Update 2011-06-01: The public beta of JavaFX is out! I’ve published on JavaFX on the Xebia-blog.

There’s a lot of talk about the IPhone 4 supposedly having bad reception. Well, the Motorola Milestone has a problem too. When calling, I very often incidentally put the telephone to mute, which causes the other party not to hear me anymore. This is caused by the mute button in the middle of the touch screen. I often press is that area with my hear while calling, as I have the habit of putting my telephone to my ear… Well apparently few people in Motorola though of that.

The Motorola Milestone has a proximity sensor that supposed to turn of the screen while calling. However, for me, that doesn’t work. I searched for a solution on the Motorola forum. There a quite a few threads about this issue, like this, this one, this on long hair and this one saying it’s a hardware problem.
Many answers are infuriating rather than useful. Most of them have tips on how to properly hold the phone (in your right hand, below ear lob, under your hair). Arg, that’s not what I want to hear. Apart from the fact that doesn’t work, I don’t want a whole instruction who to hold my phone when I’m using a mobile phone for over 10 years.
Some idiots even say they have the problem, but still love the Droid.

At least some sort of official person who sorts of answers to the problem. People at Motorola are working on an update.  That’s not of much help. Finally, in this thread I found a more useful answer. There’s an application called Screen Suite, which allows you to lock the screen while calling. It only costs $1.99. Bought it already, I have the phone to long to get my money back. I just installed the application, Screen Suite seems to work.

Well bottom line, Apple isn’t the only one with a problematic telephone. And avoid the Motorola Droid and Milestone, at least when you also want to make phonecalls with your smartphone.

Using the menu, you can open and save documents at Google Docs, in a similar fashion when you’d use MS Office Live or Sharepoint. OffiSync is free to use, but when you use the free tool, any MS Office feature that isn’t supported by Google doc is lost when you save you’re files at Google Docs. The paid version doesn’t have this disadvantage.

Hier is de officiele introductie

Op 11 november 2009 werd JFall 2009, een van de twee congressen die jaarlijks door de NLJug worden georganiseerd, gehouden. Naast de inhoudelijke sessies, is een van de mooiste aspecten van JFall (en JSpring) het ontmoeten van andere Java programmeurs. In dit Whitebook vind je een verslag van dit congres en van een aantal sessies, o.a. over Java SE 7 en de nieuwe Google ontwikkelingen. Lees het volledige artikel »

en hier is de whitebook: JFall 2009, een verslag

Every chapter goes on specific part of programming, amongst others: using meaning full names, how to write good, consise and easy-to-understand functions, writing good comments, writing good unit tests, and having a good class design. A lot of content I already knew or was at least aware of, either intuitively through experience or from other sources. However, that didn’t made reading it any less usuful, the book does very well on explaining why and offering good arguments, just to convince other people. The book also questions a lot of common practices, I did not think of before.


I’ll pick some chapters to explain more in detail the content. First chapter goes into importance of good naming. Amongst others, variable should have meaning full names, and one letter variables like j or h should be used only for simple loop iteration. Class names should correspond to domain words like Customer, WikiPage or AddressParser. Postfixes like Info (AccountInfo) or prefixes like I (ICustomer) just clutter up and don’t add anything. Same goes for prefixed variable names like m_dsc or int_ordernum. Function names should be verbs like addAccount or deletePage.
Another chapter goes on a often mis-understood or underestimated subject: writing good comments. One point the auther made is to limit the amount of generated comments. IDE-generated comments containing lots of @param, @return tags, etc., just clutter up your code while not adding information: if you use clear names, you don’t need to explain each parameter. Worse, they increase the change that of introducing ‘lies’: comments that do not corrrespond with the code the’re commenting.

Allthough the title of the book suggests it’s about programming in general, the book is slightly targeted to Java-programming. All code-samples are Java code, and some times the book refers to Java standards (like the Bean standard). C# developers could benefit from the book as well, as well as developers in similar languages, allthough some code samples could be harder to understand. Programmers in languages like Haskell, XSLT, Lisp would benifit less of the book.


I could go on, but I’d just recommend you to read the book if you’re a programmer yourself or have to manage programmers directly!

• Relational model pretty good, but we need a better implementation of the relational model, SQL, at least the way it’s used now, is just to primitive and cumbersome.
• Lot’s of new languages for the JVM, but we’re still using SQL to retrieve data from databases. Many programmers may even think that is the only way to retrieve data!
• ORM is worst of both world
  • Reinventing the wheel, caching, optimal data retrieval, query optimization
  • Relational model is more natural to retrieve data then object oriented model
  • Inheritence is not possible the way it’s possible in OO, but same functionality is still possible.
• Java Programmers are spending a LOT of time creating queries, doing optimization, thinking how to retrieve data. Java is improving, but SQL is just largely the same as it was 10 ago.
• SQL / Database integration in Java is still poor. ORM frameworks just hide away the database – usually resulting in a lot of work for database administrators and programmer’s just to tweak ill formed sql.

In short, where’s a new language for the relation model and why isn’t that language or technology emerging? What would be nice is:

1. A better language to access a relation database, that doesn’t involve lots of subqueries and joins to retrieve data.
2. A database query langauge that is truly embedded in the programming language I daily work with (Java), and not hidden behind persistence managers, xml files,  application servers.  Or just as worse, SQL hidden in quoted string or text files.

• For 1. After some searching, I found an alternative to SQL, Tutorial D.  The language isn’t main stream, but is interesting to read about. Especially if you think SQL and (relational) databases are the same.
• Also I heard a while ago about .QL on the 25 year anniversary of my university, but that’s far from mainstream either.
• For .Net there’s LinQ, but that’s little use for me as Java software developer.  At least Microsoft has a solution for 2.