Thursday, June 19, 2008

Sun Tech Days

Last Tuesday and yesterday I attended the Sun Tech Days conference in Shangrila Hotel, Makati. It was the 10th anniversary of the conference. The president of Sun Microsystems Philippines danced. There were lots of squishy thingies being thrown at the audience. The food was great. The speakers were...well, the food was really, really great. :P

The whole of Tuesday was dedicated to showing off the new features of NetBeans 6.1 like the Profiler, the GUI Builder, handy keyboard shortcuts, etc. Support for other languages like PHP and Ruby were mentioned, but this was a Sun Microsystems conference, so they never bothered to demo those.

Yesterday I was assigned by my boss to the Enterprise Track (the other tracks were Desktop, OpenSolaris, and SysAdmin). Here are the notable Enterprise topics discussed (though in some cases, more like blabbered):

  • Groovy and Grails. I was made to believe that we could choose between attending a Groovy session or a JRuby session. Turns out JRuby (an implementation of Ruby in Java) was thrown out in favor of the Ruby-wannabe Groovy. The unique thing about Groovy is that it was created with Java-interoperability in mind, such that Groovy classes can be directly imported for use in Java code and vice versa. This is really handy for people who need to work with other Java developers but who prefer dynamic syntax. Anyway, it was great to see the reaction of people to the concept of closures and to the Rails-like way of doing MVC.
  • Java Persistence API (JPA). This is now Java's standard for mapping objects to a relational database table, basically creating a wrapper for that table. There are of course other ways to do this in Java, like via other third-party APIs (only Hibernate and TopLink were mentioned), Entity Beans, or good ol' JDBC. JPA is cool because not only does it simplify object-relational mapping, it does this without the "unnatural need for special interfaces" (paraphrasing one of the speakers). It simply uses plain old Java objects (or POJO*) and relies on dependency injection** via Java annotations. The overall effect is it makes code look a lot more coherent, not to mention easier to unit test.
  • GlassFish. This is an open-source application server that implements the latest Java Enterprise Edition and uses Java NIO for faster connections. The GlassFish session also gave a glimpse to the next Java EE version and how it will use the POJO and dependency injection stuff as well. Pretty exciting, and it seems my dreams of simpler, more sensible servlet-programming is finally coming true!
  • Oracle's Coherence. For some reason a number of people started leaving the moment the Oracle guy was introduced. Quite a few more left mid-way into his presentation. Maybe because he was a corporate type with a strange accent. Maybe because Oracle is just boring. Anyway, Coherence is a way to store database records in memory, allowing for super-fast data-access. If that sounds familiar, you might've heard of memcached, which is similar but open-source. Most of the speaker's presentation was basically a sermon on the importance of scalability. Scalability is the main advantage of Coherence over memcached as it allows the cached data to be replicated and distributed across multiple machines. This leads to stability even in extreme volume of transactions. Well, okay, but I still wished I could've attended the Java SE 7 demo in the next room instead.
Other stuff I saw demoed included jMaki***, JavaFX, SVG 1.2 support for Java ME (JSR 287), and VirtualBox (running on OpenSolaris). Today it's my team members' turn to attend the final set of talks, the lucky buggers. Despite the incoherence of some of the speakers (pun intended!), the conference made me really excited about new Java platform technologies, and I'm glad the company I work for seems really interested in them. Technology is fun!

Update: I was able to catch up on the last set of talks for today. The MySQL talk (which was about MySQL 5.1, storage engines, and JavaDB) was a lot more interesting than the Oracle talk yesterday.

- - -
* Apparently acronyms make things cooler.
** Dependency injection means JPA will supply your objects with any dependency you specify. For example, if you need an object to be treated as an "entity" that maps to a database table, you simply add the proper annotation to the class definition and JPA will "inject" all the necessary database-related code into the object upon instantiation. You can therefore focus on coding the business-related aspects of the class definition.
*** Mainly they demoed the jMaki widgets integration in NetBeans. Pretty cool.