Thoughts About

JavaOne 2007: Day Three

My day three is full of interesting sessions, but this is the only day my evening looks empty - to make time for the After Dark Bash, the official JavaOne party. Motorola's key note is a little disappointing, not much about open development as it's titled and mostly hype. The first technical session is then way better: Eclipse Europa, the next release train of Eclipse platform. The Eclipse people mention this as well, but one of the most extraordinary aspects of these simultaneous releases of Eclipse projects is that while dates are decided 12-18 months before, the releases are always on time. A lot of projects could learn something from that, whether open or closed source. Also the milestone releases are typically very stable from early on. Overall, the size of Eclipse and all Eclipse projects have gone up and there's too many improvements in each one to go over in a one session. There doesn't seem to be anything earth-shattering, but of single plugins that I've heard about, but never bothered to try out, I must bring up Mylar. Mylar's this "active filter" that watches what you are doing in Eclipse and creates dynamic views showing you only the stuff that you are actually interested in.

I skip one session to have just a tiny bit of time to post my notes of the previous day. The next one is OSGi best practices that should come in handy in the future. Eclipse contains an implementation of OSGi, called Equinox, and the plugin and loading architecture is completely based on it. My quick notes explain fairly well what OSGi can do for you, but most applications bigger than Hello-World Applet would benefit from the architecture. Of course the problem is that a few applications want to be architecture-heavy from the beginning and consider these issues while the application is still small. That's why Eclipse RCP is a good choice for a lot of client application projects; you don't need to start from scratch and you have the architecture available when you need it.

My next session is about "Advanced Refactoring in Java platform". I'm really interested in the the topic but the session is mostly a disappointment; the Sun guy is demonstrating the concepts in Netbeans and most of these have been implemented a long time ago in Eclipse, not to mention IntelliJ IDE. In any Netbeans session, you typically hear somebody asking if they could just move to Eclipse. The answer is always the same, but maybe overall it's good that a major player is missing from Eclipse foundation; the competion will push both platforms forward.

I also attend Ning session, which is an interesting architectural presentation. I've been interested in the company for a long time, and while their solutions are not necessarily applicable to other architectures, they re-iterate the known principles: don't over-engineer, a single well-designed system can handle a lot of load, and simple is good.

The last session of the day for me is "Ant to Maven migration", which I picked solely because of the presenter, Jason van Zyl, the creator of Maven. Maven's no silver bullet, but their case study speaks for itself: 21,000 thousand Ant lines were replaced by 3000 lines of Maven code. Obviously, this is a big project. Maven's XML is rather verbose just like Ant's, but it gives you structure and you rarely need to repeat things; both areas where Ant often fails.

Raw notes below

JavaOne 2007: Day Two

Wednesday. I have an absolute full day from 8.30 till 11pm. I miss Oracle's keynote on 10g because I keep talking with a friend of mine at the breakfast about Java development on a mobile platform. My first techinal session is "Web Beans update", purely chosen because of the speakers, Gavin King and Bob Lee (if you don't know who these guys are, you are probably not developing Java web apps). It's an interesting session on this effort of unifying the IoC models to make the beans available to various web application frameworks in a standard EE way. I'm sure both of these guys are more than capable of making impact and creating better, practical solutions, but getting the mechanism standardized between all the invested parties... well let's just say my confidence on Java "standards" has taken some hits over the past few years.

I'm also checking out Java Persistence API 2.0. They contain a lot of low-level details of what going to be added, but mostly things that vendors/fore-runners, such as Hibernate, have already added (e.g. persistent lists), so the standard is just keepin up with the implementation extensions. I think that's the only way to make the standars really.

In the afternoon, I'm attending the location API 2.0 JSR update since a friend of mine is working on that; pretty different from my field but interesting stuff. The rest of my sessions are however focused on desktop Java and especially on Eclipse RCP. The RCP session is cool: the guy just goes through a lot of code showing how to implement a complete standalone RCP app. This will hopefully come in handy in a relatively short timeframe. I also go to "project Darkstar", which is Sun's new framework for "massive online" games. Obviously the idea is to strengthen Java's position as a gaming platform, and if I were to guess, mostly in mobile space. Nevertheless, Darkstar's core idea is this persistent storage capable of handling high volume of simultaneous write operations and synchronizing the data on multiple clients. So no relational database there. While targeted as a gaming platform, an "unnamed" vendor had re-implemented their auction system in Darkstart and claimed 15 times better through-put compared to their existing relational db implementation. Not bad at all.

In the evening, I happily skip both Eclipse and Google parties, and go for Howard Lewis Ship's Tapestry 5. I have no notes of the session because Howard simply demoes T5 by writing code with it and the slides he has go through the benefits of the framework which I knew already. While still in development, it's *the* most impressing web application development framework for Java at the moment. There are plenty of other frameworks that may have the wow effect, but none of them are as comprehensive as Tapestry as a whole. The late-night session, starting at 10pm is about Grails, so I don't have a choice but to go there as well. It's interesting to compare Grails to Tapestry. Grails guys openly say the are not a component-oriented framework like Tapestry, which is a immediate turn-off for me, but in comparison, Grails has a much deeper integration to Spring and Hibernate as well as I had expected. Their approach to persistent entities and domain-driven development is very similar to Trails albeit they don't generate the UI for you automatically. Any domain object can be immediately stored as persistent entity and associated rely on Hibernate, just like in Trails.

JavaOne 2007: Day One

Previous years I've been reasoning why JavaOne is better, so this year, I'll just settle for noting it's good to be here again. Sun general session opens the JavaOne as always, and I'm late because of the horrible traffic... Even though I'm on a motorcycle. Everything else is pretty much the same as previous years and that's a good thing in my books. Sun likes to announce big things in JavaOne and it's no different this year. The biggest thing is JavaFX brand, which by itself doesn't mean anything, but the way I read it, JavaFX Script is positioned as a direct competitor to Flash. Especially because under the same branding, they also publish JavaFX mobile - the same for mobile. I'm writing this the following day, and by now I'm sure "the blogosphere" is full of different takes on JavaFX, so google for more info. While different Java-integrated scripting engines existed even before Java SE 6, the official scripting engine support has validated the approach and created countless new Java scripting projects for specific tasks. So, JavaFX is another one of them, but this time for Sun.. for better or worse. Clearly geared towards multimedia, streaming, and graphics.. and if I'm not wrong, based on vector graphics, hopefully they endors SVG as format.

Besides JavaFX, there's many more interesting announcements in different sessions. Following my tradition, I go for sessions that are extremely bleeding and/or things not in my immediate area - on other things I can always read about from web. I've heard a lot of positive things about Groovy, but that's one language I *haven't* tried yet. Groovy is this "scripting" language that has full interoperability with Java and follows the Java syntax as closely as possible, without the annoyances. So for example, no needless getters and setters, no semi-colons, property-based access to everything etc. Scripting was in quotes, because with Groovy it's up to you: you can run Groovy as interpreted or you can choose to compile Groovy with the Grovvy compiler down to bytecode, indistinguishable from any native Java class. Groovy has been integrated into a number of projects already and I predict a bright future for Groovy.

I skipped most of the "boring" JSF sessions in the afternoon and instead opted out going for some session more out of my immediate area of expertise. I really had fun time in Sun SPOT session, which is Sun's new effort of creating a cheap-but good enough embedded system component, rather than just a single chip. Since laying out the wiring for chips in embedded systems is so expensive, SPOT takes the approach of providing a personal-area network and multiple connectors, like analog-to-digital-inputs, different sensors and a 32-bit ARM CPU running a version of JVM on "bare metal" plus a basic Java framework to handle the inputs. Pretty cool, no? So, they were demoing a home-made WII which didn't go entirely without trouble, but the point is bringing the cost down of building something like it by providing a common platform. Perrone System's "All you want to know about robotics and Java" continued on the same trails. They were focusing on building a higher-level Java framework to handle low-level I/O, like controlling servos or combining readingis of gyroscope and accelerometer so system developers could focus on higher level tasks - like "turn wheels 20 degrees" - rather than dealing with all the different states of servos, "oversteering" etc. In the end, they showed a video with all the applications built on using the framework, among them a car participating a DARPA autonomous driving challenge and side-parking the car by itself! The future truly is here.

The session I needed to stick around till 10pm at Moscone center was however about the ruby-like frameworks in Java: Grails, Sails and Trails. It was rather interesting to hear somebody else talking about a framework you are developing, namely Trails. Even though I noticed his information was a little - since I've been rather active on Trails in the past two monst, most of documentation is completely re-written and there's a lot of other minor improvments - Trails was fairly accurately presented and faired well against the others. However, I was mostly interested in Grails as though I had heard about it, I had never tried it out. Of course, I was looking for synergies there, but as Trails is very much a Tapestry framework, and Grails uses their custom view technology, there isn't a way the projects could be easily combined. Nevertheless, using Groovy for coding Trails is certainly possible and something I might look into in the future in order to make it easier for the users.

As in previous years, my raw notes are in the extended entry

JavaOne 2006: Day Three

Darn. I missed the beginning of IBM's morning keynote. Typically it wouldn't be a big deal as the keynotes, especially the non-technical ones, are mostly marketing talk and thus not-so-interesting for me, but this time it was really good: IBM walked through the whole development process of Eclipse, showing loads of plugins they are using, the testing systems etc. Eclipse may not be *the only IDE* anymore, as NetBeans and IntelliJ IDEA have been making some waves recently, but Eclipse's development and shipping track record is incontestable. From Eclipse WTP 0.7, every milestone build has shipped at the exact date decided a year or more earlier, there are no build re-runs because of issues emerging after the release and the milestone builds tend to be highly usable very early on. It's quite a lot better than our track record... Anyway, they call the development environment Jazz and some of the plugins are already publicly available and some others undoubtedly will be released sooner or later - I have to see if there's anything we could use.

I tend to choose sessions that are *really* bleeding edge and I don't have much knowledge about. I see no much point sitting in standard EJB 3 best practices or web application frameworks smackdown sessions as they don't offer me anything new or anything I couldn't just read on the web. So logically, I found myself in many Mustang/Dolphin (Java 6 / Java 7) sessions, one of them being "Dynamically typed languages in Java platform". This session was held by Gilad Bracha, obviously a _very_ senior engineer working on JVM development at Sun and leading some of the JSR proposals (Same guy that held the controversial super packages session the previous day). He has very dry, but entertaining humor, take these quotes for example: "So some people are asking why do we need these dynamic languages, and, because they've lived in this dark cave for all their lives, they have no idea of what they could do with them" or "and I proposed this several years ago, but customers weren't asking for it at the time... of course, entirely different matter is customers weren't asking for Java either, but sometimes the customer just doesn't know what's good for them". Anyway, a scripting/dynamic language support inside JVM is a good thing, and much less of a controversial topics as super packages are. I really like dynamic, untyped, late-binding languages, but after some years of LotusScript, JavaScript and ActionScript hacking, I do know their limits as well. Most of the dynamic scripting languages tend to be classless, prototype-based languages today, which I view as a good thing.

I had to go to "Advanced JavaServer Faces Custom Component Development", but I knew I'd be disappointed. People are hacking together some cool components, like SVG rendering for charts and bars - boy, it's a doom's bell for Flash - but overall, writing JSF components look like how servlets were done 10 years ago, outputting HTML directly from a servlet, or writing SQL without any persistence layer (JDO, iBatis, Hibernate). It works on a higher abstraction layer, but developing and maintaining the component code is a mess. XSL transformation approaching would have been a much cleaner approach, albeit likely slower.

DOJO session was next - Dojo is making its way to become the de-facto Javascript framework for server-side Java web application framework, both used in MyFaces subprojects and Tapestry. This is one of the key thing and problems with prototype-based languages: because they are so flexible, any object can change the run-time behavior of object ancestors and happily overwrite critical properties or operations. This is why a single (or only a few) framework that's good enough is so important for any high-quality Javascript implementation, much so than for a statically typed class-based language. It's also where Macromedia went so wrong with ActionScript 2.0 by adding class-like features into an inherentely prototype-based language. DOJO is cool.

In the evening, I attended the MyFaces party organized by Oracle and CA. Among others, even Craig the man, err, McClanahan was there, and of course a lot of other people I knew only through mailing lists before. It's nice to put faces on names. One of the topics I discussed with Craig, and complimented him on improvements in NetBeans (he's leading Java Web Studio Creator at the moment) and of course, we glanced off the touchy subject of Sun possibly ever collaborating with IBM on Eclipse. Craig's response was expected: "You know, for starters, they'd need to change the name" ;)

The last session of the day/night was Trails (starting at 10:30PM!), I just really wanted to go see it and meet the guy behind it. In short, Trails is domain-driven development model in Java along the lines of Ruby on Rails and NakedObjects, only better (subjective opinion of course, but because it combines best of breed frameworks already existing in Java).