Just finished up an extremely busy week at JavaOne and there was a lot to like about this year’s event.  There were plenty of surprise announcements, lots of good content/sessions, and a lot of improvements on the venue and organization.

For folks who have been patiently waiting for me to publish all my talks, I apologize for the delay…  giving 4 talks + a keynote (plus 3 more talks at Silicon Valley Code Camp yesterday) was a lot more work than I expected.  To make sure I can cover the topics and code in enough detail I am going to publish 1 talk plus commentary a day for the next week.  Please follow me on twitter or rss to catch the updates as they roll out.

To get you started, here are some of the highlights from JavaOne:

JavaFX is back in the spotlight!

After a year of hibernation, JavaFX is back with a 2.0 release, big open source announcement (more on this below), and mobile prototypes on Android and iOS.  For those naysayers who said JavaFX is dead, Oracle has proved that they are going to continue to move the platform forward and support state-of-the art development on Java client technology.  As always, Jasper and the rest of the JavaFX team had some pretty impressive demos and the entire Java community was re-energized about the future of client Java.

If you haven’t already, go download JavaFX 2.0 right now!  It is available in production for Windows and there is a developer preview of Mac OS X, so you have no excuse for not trying it out today.  (unless you are on Linux…  but that is supposed to be coming soon too)

The Open Source Petition Was Successful!

Thanks to all my blog readers who spent the time and energy to sign and support the petition to open source JavaFX.  In part due to the huge community sentiment about the need to open source JavaFX, Oracle has taken action and promised to open source the entire platform.  They are going to start with the controls library as announced last year, and continue to open source the entire platform as part of the OpenJDK project.

This is a huge benefit to JavaFX, which will finally be getting equal treatment with the rest of the Java platform.  They are also actively working on getting JavaFX to be fully redistributable, which will remove yet another obstacle to making JavaFX the standard for desktop development.

Community, Community, Community.

Oracle has been listening to the Java community, and put in place many of the changes and suggestions that were raised.  This was evident in the entire JavaOne conference, which was a huge improvement over last year’s event.  Some of the improvements that I noticed while hanging out at JavaOne this year included:

• A Community-focused Keynote – While I may have been biased as a participant, I thought the best keynote of the conference was the wrap-up community keynote that Sharat Chander lead.  This included some amazing demos by the Duke’s Choice Winners of audible development for the blind and home automation using Glassfish, a spicy panel that had a lot of positive things to say about the Java Community and OSCON Java, and a surprise appearance by the Java Posse who were at 3/4 of their finest!  (the 1/4 being poor Tor, the Googler)
• Community Hang Spaces – While navigating the conference it was much easier to bump into folks you know by hanging around one of the many hang spaces that were built out around the venue.  In fact, Dean Iverson and I found ourselves preparing for one of our talks in the hang area, because it was more conducive to collaboration and interaction than the speaker room.
• Easier Venue Navigation – A couple things contributed to this…  One was that all 3 hotels were reserved for JavaOne talks, so you had more talks concentrated in the same vicinity.  Another was the plethora of helpful staff directing traffic and answering questions (I made quite a lot of use out of this myself).  Finally, the signage and open tent configuration made it much easier to get form Point A to Point B.

And a Few Things to Improve for Next Year…

Everyone has their personal gripes…  here are some of mine:

• Fewer Sponsored Keynotes – When you pay big $$$ to attend a conference, the last thing you want to do is sit in a session and watch a canned talk by a corporate stooge.  The Juniper Networks talk was a particularly blatant example of something that was not really focused on the Java crowd tossed in as a sales kick-back.  In the future, it would be better to make the sponsors earn the attention of the attendees by labeling the talks as sponsored and giving attendees some alternatives.
• Better Network Connectivity – It was almost impossible to get on the wifi network in any crowded situation (like a session), and once connected the response times were abysmal. That is until everyone left around Thursday midday and the network started going blazingly fast for those who stuck it out for the last few talks. 
• Improved Tech Support on Talks – I listened to the presenter advice and formatted all my slides in 16:9, which didn’t seem to work for the first couple talks that had big black letter-boxes above and below the slides.  Also, my first talk had no network connectivity on the wired connection (and as I mentioned, wireless was useless).  However, I had to the good fortune of giving way too many talks, so by the time I got to my 3rd and 4th ones they seemed to have figured out how to use the very expensive screen adjustment boxes and got everything tuned just right.  Also, the wired network seemed to work fine in all the other rooms I hi.
• Patching Things Up With Google – This is the second year that Google has refused to let anyone speak at JavaOne. They blame the lawsuit for this, but at some point the policy is more retaliation than just good legal defense. (Is letting Tor speak on stage in a community setting is really going to jeopardize the Android platform?) The real losers in this battle are the average developer who is missing out on great technology and content from one of the most innovative companies in the world.

Overall, JavaOne was a great conference this year, and is definitely back on the upswing.  There was mention of improving the venue in the community keynote, and I hope the upper management at Oracle takes this seriously.  The 3-hotel setup is not ideal, and really not large enough to contain the Java community.  It is time to unleash the Java Community in a full conference venue of its own.

JavaFX 2.0 and Scala are both great technologies individually, but work even better when used together.  JavaFX 2.0 is a powerful rich client technology with advanced graphics, animation, and media capabilities.  Scala is a simple, yet powerful language with advanced language features for writing domain-specific languages (DSLs).  Add a little Scala UI DSL to your JavaFX 2.0 project and you will be in cookie and cream heaven!

Time Lapse Photography Creative Commons Licensed by Robbie’s Photo Art

JavaFX Colored Circles

I will go into more detail on why Scala in a bit, but I believe this is all best illustrated with a code example.  One of the basic examples of JavaFX 2.0 functionality that comes with the SDK is a sample application called ColorfulCircles.  The full source code can be found here:

Java Colored Circles Code

With the help of Sven Reimers, we ported this to Scala on top of the ScalaFX library.  The working application source can be found here:

ScalaFX Colored Circles Code

Update: Dean Iverson has a great example of the same code in GroovyFX

Feel free to peruse the source code at your leisure, and take note of the following:

1. ScalaFX is More Concise

The ScalaFX version is shorter both in number of lines and more importantly number of characters.

Code Count (excluding licenses and imports):

• Lines:
  • Java: 48
  • ScalaFX: 42
• Characters:
  • Java: 1602
  • ScalaFX: 866

This is due to custom tailored DSL language that is fully expressive with less redundancy.  In the Java version of the code you will notice a lot more boilerplate and syntactic repetition that is required by the language.

2. ScalaFX Code Looks Like the Output

While the output of the Colored Circles example is quite simple, it actually hides quite a bit of complexity in the way it is structured.  Here is the output run from JavaFX 2.0 Build 45 using ScalaFX:

What you are actually seeing is a SceneGraph composed of the following layers:

• A Scene with a black background that contains…
  • A Group that contains
    • 30 semi-transparent Circles covered by…
  • A rainbow-colored Rectangle overlay

When reading the ScalaFX code you get this nesting through the object-literal style declaration of the Nodes in the Scene as excerpted here:

// ScalaFX Scene Excerpt:
scene = new Scene {
  content = Seq(
    new Group {
      circles = for (i <- 0 until 30) yield new Circle { ... }
    }
    new Rectangle { ... }
  )
}

However, the Java version does not give you the same hierarchical representation, and instead uses an imperative series of calls to constructors, getters, and collection methods.

3. Tailored Animation Syntax

Animations are very commonly used in creating good UIs, which is why JavaFX Script had a built-in construct to simplify the creation of animations. ScalaFX has a similar syntax that allows you to quickly and easily create animations, which is used in the ColorfulCircles example:

Seq(
  at(0 s) {circle.centerX -> random * 800},
  at(0 s) {circle.centerY -> random * 600},
  at(40 s) {circle.centerX -> random * 800},
  at(40 s) {circle.centerY -> random * 600}
)

This makes it trivially easy to create complex animations.

4. And the ScalaFX Version Has a Hidden Bonus Feature…

Unlike the JavaFX version, the contents are bound to the width and height of the stage. Binding in ScalaFX is as simple as replacing the assignment operator (=) with the bind operator (<==) as shown here:

// ScalaFX Property Setting:
width <== scene.width
height <== scene.height

While this is a simple operator change in ScalaFX, it requires complex enough code that they decided to omit it from the JavaFX sample. A loose translation to Java would be the following:

// Java Fixed Property Binding
colors.widthProperty().bind(scene.widthProperty())
colors.heightProperty().bind(scene.heightProperty())

Although, the precise equivalent code in Java syntax would actually be the following:

// Java Dynamic Property Binding
colors.widthProperty().bind(Bindings.selectDouble(primaryStage.sceneProperty(), "width"))
colors.heightProperty().bind(Bindings.selectDouble(primaryStage.sceneProperty(), "height"))

Either of these versions is quite a bit more complex and unwieldy than the ScalaFX equivalent, and this is for a very simple binding!

About ScalaFX

ScalaFX is a UI DSL written within the Scala Language that sits on top of JavaFX 2.0 (not to be confused with Ingo Maier’s great work on Functional Reactive Programming for Swing). This means that every ScalaFX application is also a valid Scala application. By extension it supports full interoperability with Java and can run anywhere the Java Virtual Machine (JVM) and JavaFX 2.0 are supported.

Some of the features of ScalaFX include:

A Programmer-Friendly Object-Literal-Like Syntax

ScalaFX uses a simple, hierarchical pattern for creating new objects and building up the scene graph.  Here is a simple example that creates a new stage with a rectangle that changes color based on mouse events:

stage = new Stage {
  title.value = "Hello Stage"
  width = 600
  height = 450
  scene = new Scene {
    fill = Color.LIGHTGREEN
    content = new Rectangle {
      x = 25
      y = 40
      width = 100
      height = 100
      fill <== when (hover) then Color.GREEN otherwise Color.RED
    }
  }
  visible = true
}

Unlike the builders you find in the core JavaFX APIs, the ScalaFX object declaration syntax uses the normal object API. This means that you can use the same operators and convenient syntax to create and modify your scene graph. Also, anything that is permissible in a Scala block (such as variable declarations, method calls, binding, etc.) can also be done inline while constructing objects. For JavaFX builders you need to declare binding after you finish creating your objects, which leads to disassociated and hard to maintain code.

Natural Language Bind Expressions

One of the greatest advantages of using the Scala language as a DSL is the rich support for operators as methods. This is similar to the C++ concept of operator overloading, but much more uniform and clean in its application.

The ScalaFX bind library exposes normal operators such as &&, ||, +, -, *, / on top of all bindable objects. Also, Scala supports operator precedence, so it looks and feels like you are writing normal expressions even though you are creating bound objects under the covers. As a result, you have the full functionality available from the JavaFX 2.0 binding libraries with code that looks akin to mathematical expressions and operators.

Here are some examples of what you can do with the ScalaFX bind API:

Infix Addition/Subtraction/Multiplication/Division/etc.

height <== rect1.height + rect2.height

Aggregate Operators

width <== max(rect1.width, rect2.width, rect3.width)

Conditional Expressions

color <== when (hover) then Color.GREEN otherwise Color.RED

Complex Boolean Expressions and String Concatenation

text <== when (rect.hover || circle.hover && !disabled) then textField.text + " is enabled" otherwise "disabled"

Free-form Invalidation and Change Handlers

rect.hover onInvalidate {
  needsRepaint = true
}

Fully Type-Safe APIs

This may seem like an insignificant point…  Type safety is something that Java developers have always had (and often take for granted), and developers in other scripting languages live without (and unknowingly suffer with runtime errors as a result). However, it is a critical feature if you are developing applications that cannot have unexpected runtime errors and bugs after deployment.

A good compiler will be able to pick up many common coding mistakes through comparison of expected and actual types, and a great compiler (like Scala) will automatically infer types for you so you don’t have to tediouisly repeat them throughout your code.

ScalaFX gets the best of both worlds with a scripting-like DSL syntax where you can rarely have to explicitly type objects, with the strong type-safety of the Scala compiler that will infer and check the types of every expression and API call. This means less time spent debugging weird code bugs and misspellings, and higher quality code right out of the gate!

Seamless JavaFX/ScalaFX Interoperability

It is often the case that you do not have complete freedom about the predominant language of the codebase, or of the libraries you are including functionality from.  Even in a mixed environment codebase where you have Java, Scala, and possibly other JVM languages, ScalaFX will seamlessly convert and interoperate.

ScalaFX gets this functionality through the implicit operator capabilities of Scala.  Anywhere your program expects a JavaFX typed object, it will automatically insert the code to convert from ScalaFX wrapped objects to JavaFX native classes.  Any time you use a ScalaFX specific feature, the compiler automatically creates a ScalaFX wrapper object that allows you to call advanced methods and access the full functionality. This all happens behind the scenes, letting you focus on writing clean code, and not fussing about integration and interoperability.

With all this interoperability magic happening behind the scenes, there is some additional overhead on your application. We have taken pains to minimize this using features like @specialize in the Scala language, which allows us to avoid boxing and unboxing costs on primitives. However, without real benchmarks it is hard to tell just how good of a job we have done. Hopefully more on this in a future post.

Finding out More About ScalaFX

The ScalaFX project site is hosted by Google Code including a couple mailing lists that you should join if you are interested:

• ScalaFX Users
• ScalaFX Developers

At the time of writing we do not have a bundled release, but are interested in early adopter feedback.  If you would like to give it a try, please download the source and give it a quick spin!

I will have more details about ScalaFX at my upcoming JavaOne session with Dean Iverson entitled “JavaFX 2.0 With Alternative Languages“.  Come to hear more about Scala, Groovy, and other JVM languages you can use to write simpler, cleaner code.

The JavaOne Session Builder is now up and available for setting up your sessions. If you are not used to the JavaOne ritual, it is always a good idea to sign-up for sessions well in advance so you don’t get bumped out of the more popular ones. This also helps them fix the room allocation so popular talks get the right size room.

I put together my own schedule of all the JavaFX-related content I plan to attend, and published it on Google Calendar. It is also a pretty good guide to some of the top JavaFX content that is being featured at JavaOne this year. — Apologies to my fellow speakers with conflicting session slots. I wish I could be in multiple places at once, but even rich client technology is not that advanced — yet.

Note: Click for details — sessions I am actually giving are highlighted in green.

Also, for those of you brave enough to attempt to use the schedule builder, it is no simple feat. The UI is fairly convoluted, so getting your schedule tweaked to be just right takes a lot of time and experimentation. Fortunately, I did a lot of this work for you and have figured out the happy path through the system.

JavaOne Schedule Builder Happy Path:

1. Login to the system and go to the JavaOne Content Catalog
2. Setup your filters to get the sessions you want (if you are reading this, you probably want to search on “javafx”)
3. Click on the stars to pick the sessions you are interested in — this adds them to the “My interests” list
4. Finally, click on “Schedule My Interests” and follow the little wizard UI

Just about any other path through the system (scheduling by time, resolving conflicts as you add sessions, etc.) is fraught with peril, so be warned.

Enjoy, and I hope to see you at JavaOne!

What was the last conference you went to where you felt like you actually had a positive impact on the larger technical community? A lot of conferences feel like corporate marketing where companies (usually the ones that pay the big sponsorship $$$) are pushing you to buy services or product. Other conferences feel like brainwashing where the message is constrained by a “Ministry of Truth” that limits the topics and speakers to those that align to their world view. No matter how many big parties and aging rock stars they truck in to woo the masses, you leave the conference feeling like you have been sold a technical lemon.

If you were fortunate enough to be at OSCON Java this past week, you were able to experience a different type of conference first hand.  Here are some of the ways in which OSCON Java was not just another technical conference…

Hacking for a Purpose

What was the last time you got to sit down side-by-side with a conference speaker and technical guru such as Joe Darcy, Stuart Marks, Bob Lee, and Jeff Genender, and hack out some code?  We setup and experimental hacking session where we did exactly this, pairing up attendees 1-to-1 with expert hackers to convert an open source codebase to use Java 7 features.  For this project we chose Google Guice (no surprise) and by the end of the session had converted several source files to use new Java 7 features such as strings in switch, the diamond operator, and try with resources.

In addition, we also had a follow-on event after the very successful OSCON JVM Languages Symposium to work through a technical solution for JVM language interoperability. Normally this is something that could take months of technical debate to come up with a few possible solutions, but with the collective brainpower of several compiler authors and some technical herding by Ben Evans, they came up with a solution after only several hours.

No Corporate Shills

At OSCON Java you got to see leaders from across the industry standing side by side up on stage, and being transparent about how their corporate strategies affect technology and open-source. Steve Harris, SVP at Oracle, was bluntly honest about his corporation’s failings in communicating to the Java community and made the point with some funny, self-deprecating slides, such as the “Oracle Threat Level” diagram:

However, he ended his speech on a high note with enthusiastic support for the Java community and Java User Groups in particular:

“Java User Groups Rock!”

And Some Geeky Fun

A good technical conference would not be complete without good, geeky fun. For this, we converted one of the exhibition halls into a giant carnival, complete with clowns, games to test your strength, obstacle courses, and of course plenty of carnival food. It was quite a stark difference from being in a tech conference surrounded by screens and computer, and was a great break from typical networking events.

My money in the above race is definitely on Fabiane Nardon (center), Brazilian Java User Group Leader. Once she sets her mind on something, she is extremely determined!

While you may have missed out on one of the greatest Java events since the collapse of Sun, you can still catch some of the best parts on the OSCON video site:

http://www.youtube.com/user/OreillyMedia#grid/user/93FC98105B19725C

Also, all the speaker slides are now available for the presentations:

http://www.oscon.com/oscon2011/public/schedule/proceedings

See you at OSCON Java next year!!!

This past weekend we held the very first OSCON JVM Languages Symposium.

This was truly a meeting of minds with a huge brain trust of language authors, JVM hackers, and professional developers tackling some of the biggest issues for the Java community at large.

I think we had a pretty good recipe for success that went something like this:

• We ate some yummy Voodoo Donuts
• (while discussing the impact of Java 7++ on JVM languages)
• Washed down our donut remains with some of Portland’s finest Stumptown coffee
• (while discussing JVM language interoperability)
• Had some tasty pizza and drinks on a private patio
• (while pontificating on JVM community dynamics)
• And then back for some more Voodoo Donuts…

As you can see, we took our work (and play) very seriously.

Thanks to our sponsors, Typesafe and OSCON, this event was entirely free to the participants.

The full proceedings of our event can be found below… given the success, I am looking forward to making this a long standing OSCON Java tradition!

OSCON JVM Language Proceedings

Conferences are expensive…  they assume you work for a stacked megacorporation that believes the fastest path to increasing their shareholder value is investing in your individual career training.  If your employer is not having a great year or has had a surge of resignations from last year’s crew of esteemed conference goers, chances are that you won’t be getting reimbursed to attend your local geek-fest.

Fortunately for you, I happen to know the inside secrets to enjoying all the conference perks at OSCON without handing over a single Benjamin.

Secret 1:  Conference pre-events are free and easily crashable!

Today I dropped in completely unexpectedly on the Community Leadership Summit today, and even after boldly announcing myself as a party crasher was awarded with a super-secret badge (a.k.a. index card w/sharpie etchings).  This gave full access to their sessions and let me attend the after-party for free drinks!

Tomorrow I am planning on crashing the free OSCON JVM Languages Symposium…  I hear they have some of Portland’s scariest pastries being brought in and might even be doing a free lunch outing thanks to their sponsor, Typesafe.

It helps that both of these events have an unbelievably high Rockstar to attendee ratio…  more on why this matters a little later.

Secret 2:  The best type of conference pass is the free type

There are 9! different OSCON passes available for you to choose from on the registration site.  While this is a bewildering array of options, but if you pay attention to the price it is quite an easy decision.  Click the “Register Now” button below and you are good to go:

Register now for a FREE Expo Hall Pass (use code EXPOPASS)

So what are you missing out on with an Expo Pass?  Well…  you can’t sit with the rest of the attendees and listen to a canned lecture, but you can hang out with your new Rockstar friends in the hallways.  Which takes us to Secret 3…

Secret 3:  Conference value = # of Rockstars / # of Attendess

This makes sense if you think about it…  if you were the only attendee, surrounded by a cluster of speakers and geniuses waiting to impart their knowledge on you, it would be infinitely valuable.  Most conferences you are one speck of sand in a huge pool of attendees vying for a little bit of wisdom to be imparted on your section of the audience.  The smaller the audience, the more chance you might actually get something of value out of the experience.

So what does this mean for the value you get from difference conference events?

• Keynote = 1 speaker to 1000 attendees:  Avoid this at all costs…  you can always get the highlights off twitter, so who cares.  [as you can see, my days as a conference chair are clearly numbered.  ]
• Technical Session = 1 speaker to 100 attendees:  This is slightly better, but still the odds are clearly against you!  [yes, and now my days as a speaker are coming to an end as well...  see if anyone invites me to give a technical talk again]
• Birds of a Feather Sessions = 1 speaker to 30 attendees:  A slightly better ratio, more focused, and absolutely free!
• Ignite = 30 speakers to 300 attendees:  Ignite talks are for the speaker grazer in all of us…  yeah, talk your heart out…  for 5 minutes.  If you haven’t impressed us in that amount of time, at 40 minute session will not change our opinion.  It also helps that this event is absolutely free!
• Unconference = 20 speakers to 100 attendees:  Now we are talking.  With this many technical gurus walking around you are virtually bound to learn something…  without even without trying!  This includes the JVM Languages Symposium and Community Leadership Summit, both of which are free!
• OSCON Hallways = 1 speaker to 1 attendee:  When you bump into Martin Odersky in the hallways after having had some good times over beer and pizza at the JVM Languages Symposium you are at a ratio where the real value comes in!  (and didn’t pay a dime to start the conversation)

If you were paying attention, you probably noticed an interesting relationship…  the most valuable parts of the conference were the parts that cost absolutely nothing to get into.  (don’t let your megacorp friends know about this, or all the wonderful corporate sponsorships that pay for all these extras might dry up!)

Secret 4:  Free stuff is the open source way

Open source is all about giving software out for free, right?  Well, maybe there is more to it than that, but there is still plenty of free conference stuff flying around that you can take advantage of with over 60 exhibitors waiting to hand you prizes just for the privilege of scanning your free badge!

Secret 5:  And parties galore!

While all those folks who paid for the high priced admission tickets may think they are special, the reality is that from a sponsor’s point of view, their eyeball is worth exactly the same as yours.  This means that you have an equal opportunity to take advantage of the most important part of any conference experience…  the parties!

Here are some of the free events that you won’t want to miss out on:

• Opening Reception – Grab a drink and mingling with exhibitors and fellow attendees
• OSCON Carnival – Join us for food, drinks, entertainment, and lots of good old fashioned fun
• Puppet Labs Party at their headquarters in Portland’s Pearl District.
• OpenStack Party – Join OpenStack for cocktails and hors d’oeuvres at the Spirit of 77
• Surprise Attendee Event on Wednesday evening (sorry, we can’t tell you anything else about this event because it’s a secret)
• Booth Crawl where you can quench your thirst with vendor-hosted libations and snacks while you check out all the cool stuff in the expo hall.
• Media Temple Party at the Jupiter Hotel with open bar, music, and all you can eat tacos!

Final Secret:  Everyone can be a Rockstar

What makes the difference between a Rockstar speaker and an attendee?  Just the drive to do something with technology and be proud of it.  You can be an open-source contributor, user group leader, and technical speaker if you simply apply the skills you already have to the benefit of the community.  Don’t expect to get paid much, but at least it is a really easy way to get invited to conferences around the world.

—-

While this article is all meant in good humor, on a serious note I want to thank the O’Reilly folks for putting on OSCON, offering discounted expo tickets, and compiling this great list of free events.

OSCON Java is a new conference that I am helping to kick off as co-chair this July.  While there are plenty of conferences out there that you could attend, I am confident that this is the one you won’t want to miss.

To celebrate the Java 7 release, I put together 7 reasons why you should attend OSCON Java.  Also, make sure to use the 20% discount code of “OS11COM” when you register:

1. Come Celebrate the First New Java Release in Half a Decade!

The last major release of Java was Java 6, which came out 5 years ago on December 11, 2006. After only a year of the Sun acquisition, Oracle has already made a major Java release happen with another scheduled in a year’s time.

We have broad coverage of the Java 7 release with a keynote and technical session by Joe Darcy, and technical sessions on OpenJDK and Coin by Dalibor Topic and Stuart Marks. I have been pretty impressed with Stuart’s coverage of topics from a developer’s perspective and am looking forward to his talk myself.

2. Because Google Matters

Regardless of what you think about the Android lawsuit, I think the biggest detriment has been the lack of good content on Google technologies at Java conferences. We are an independent conference, so it allows us to bring content that you would otherwise not find, such as an exclusive keynote from Joshua Bloch and several mobile Android sessions to help you leverage your Java skills on modern devices.

3. You Think JVM Languages are Cool

It has been said that the crown jewel of the Java platform is the JVM, not the language. Java 7 has further solidified this with better support for dynamic languages. Come find out what is the latest and greatest on the alternative language front with a keynote and some meaty sessions from Martin Odersky, deep technical sessions on Groovy, Clojure, Scala, and other languages, and some bytecode hacking with Charles Nutter.

4. And You Wouldn’t Mind Hanging out with JVM language Authors for a Day…

On the Sunday before OSCON we are organizing a free JVM Languages Symposium that many of the speakers will be attending.  This is a great opportunity to hang out with JVM language authors and the movers and shakers in the industry in an informal unconference atmosphere.  Events like this are what I believe sets apart community-driven conferences from large corporate events, and provide a lot more value to the attendees than simply one-way content.  If you happen to be in the Portland area, you can drop by for this free event with no obligation to stay for OSCON.

5. Your Boss Won’t Let You Fly to Belgium

I travel to speak at different conferences around the world and I would have to say that the golden standard for Java conferences is Devoxx. They have an amazing venue — it is great to see your slides on a huge movie screen, and relaxing for attendees to take it in from nice, plush seats. They attract an international audience… not only Belgium, but Italy, France, Germany, and citizens of many of the other surrounding countries consider Devoxx their home conference. Even though Devoxx is a wildly successful conference, they still have a small-conference feel, run by a very tight knit conference committee that acts more like a user group than an organization. This makes the entire conference experience much more personalized.

OSCON Java has a lot of similarities with Devoxx. It has a small, enthusiastic program committee with folks who really care about Java technologies. We are also following the Devoxx model of recording and posting talks online afterwards, so even if you miss a great talk because you are in the room next door, you can always watch it online later. Finally, since we are an independent conference, you get the full experience of Java, Android, and other technologies that you would otherwise have to go to multiple conferences to see.

6. OSCON is a Pretty Sweet Conference as Well…

The O’Reilly OSCON conference has been underrepresented in the Java community, but is a pretty huge event in its own right.  They have some amazing content around emerging languages and mobile platforms.  Plus, you can get OSCON, OSCON Java, and OSCON Data all wrapped up in one neat package with the OSCON Superpass.

7. There is Only One Inaugural Year!

This is our first year putting on OSCON Java, so we are pulling out all the stops with the best speakers, tutorials, content, and events.  You will have a unique opportunity to participate in the creation of a new Java tradition, and a decade from now can brag to your friends about being a founding attendee of the biggest open-source Java conference in the world.

It is pretty easy to get lost in the media hype around the Java events of the past year.  If you follow the headlines, you might believe that all the Java talent left Oracle in a mass exodus, Larry hates open source, or Java is turning into the next COBOL.  Regardless of the factual correctness of these headlines, the Java ecosystem is about more than a single company or set of individuals.  Java has the largest open-source community of any language in existence!

So how big is Java and open-source?  Here is an informal search poll of some of the most popular open-source project hosting providers:

The data for this chart comes from the top six open-source hosting providers using Google Search as a metric for gauging activity level for each of the platforms.  As you can see, Java is still the most active open-source platform in the world, followed closely by PHP and Python.  While not an indicator of language popularity, Bill Gates has gone on record speaking out against open source, so the poor representation from the C# community is not surprising.

This takes us to OSCON Java, which is a new conference I am helping to kick off as conference co-chair together with Laurel Ruma.  It is colocated with OSCON in Portland, Oregon, but is exclusively focused on Java and open source.  O’Reilly is the conference organizer, but they are very neutral when it comes to corporations and technologies.  This allows us to reach out to a wide variety of Java technology players including Apache, Google, Adobe, Oracle, the JCP, and many others.

We have big plans for the OSCON Java keynotes, technical content, and exhibitors.  Also, we are working on making this a model conference from the get-go based on my experience attending and speaking at premier conference venues across the world.  Expect a huge focus on community outreach, a lot of interaction between speakers and attendees, and a particular focus on the JVM languages of tomorrow.

If you are interested in participating as a speaker, it is still not too late to submit a talk.  The CFP ends on March 28th (4 days!), so you still have time to submit a last minute talk:

http://www.oscon.com/oscon2011/public/cfp/159

If you have a great idea, but can’t get your talk together in time or miss the deadline by a few days, shoot me an e-mail via the contact form on my blog.

I look forward to seeing you at OSCON Java, uniting the Java open-source community towards a brighter future!

I was fortunate enough to be invited to speak at the Chennai Java User Group during my trip to India.  I was expecting a small group of very devoted Java fans; however, I was surprised to walk into a room of over 200 developers eager to learn about JavaFX 2.0.  The venue was very impressive with rows of workstations that we later used for a lab, as well as plenty of seating.

Chennai User Group Venue at Tenth Planet

Also, Raj was a great host, and both he and the folks at Tenth Planet went completely over the top with this event.  This included:

• A life-size poster with the event details
• An ornamental flower arrangement with the event details
• Two gifts presented at the conclusion of the talk

Life-Size Event Poster

The session ran from 10AM through 4:30PM with a break for lunch in the middle.  When half the hands went up for returning after lunch, I didn’t believe most of them would be back, but we easily had 60% of the folks back in their seats by the time we were ready to start.

If you are interested to see the slides from the talk, you can find them on Slideshare here:

Thanks again to the folks in the Chennai JUG for being great hosts!

I have been busily working away at getting Visage ready for developing Android applications. It is a great fit, because Android converts regular Java class files into its special class format, and the Visage compiler happens to generate Java class files. Also, Android is desperately in need of some TLC on their APIs (more on this in a future blog).

So why use Visage for coding Android applications? We do a yearly Hack-a-Thon event at my company (this year called the GXS Xathon). The winning application was written by Tim McNamara, one of my coworkers, and happened to be an Android application.  I decided to do a small port of his code to see if I could improve the maintainability using Visage.  Here is a screenshot of the application:

A base settings page for an application.  It uses a couple edit text fields, several lists, and takes advantage of the summary line to display the current values.  The original version included:

• A Java PreferenceActivity class file
• An XML UI layout descriptor
• Another XML file for array resources

Believe it or not, this is the minimum necessary set of files to create the above screen.  In converting this to Visage, my goal was to get rid of a lot of the redundancy and glue code needed to work across 3 different files.

The end results of the conversion were as follows:

	Files	Lines	Characters
Raw Android	1 Java, 2 XML	208	7413
Visage Android	1 Visage	90	3640

While the numbers are impressive, what really matters is the code.

Here is the final Visage code for the settings page:

public class Settings extends PreferenceActivity {
    var senderPref:ListPreference;
    var receiverPref:ListPreference;
    var statusPref:ListPreference;
    var pollingPref:ListPreference;
    var passwordPref:EditTextPreference;
    var usernamePref:EditTextPreference;

    override var screen = PreferenceScreen { // 1
        preferences: [
            PreferenceCategory { // 1
                "Preferences" // 2
                preferences: [
                    usernamePref = EditTextPreference { // 1...
                        "Username" // 2
                        key: "usernamePref"
                        summary: bind if (usernamePref.text == "") "Currently undefined" else "Current value: {usernamePref.text}" // 3
                    }
                    passwordPref = EditTextPreference {
                        "Password"
                        key: "passwordPref"
                        summary: bind passwordPref.text.replaceAll(".", "*"); // 3
                    }
                    pollingPref = ListPreference {
                        "Polling Interval"
                        key: "pollingPref"
                        defaultValue: "60000"
                        entries: ["30 seconds", "1 minute", "5 minutes", "10 minutes", "15 minutes", "30 minutes", "1 hour"] // 4
                        entryValues: ["30000", "60000", "300000", "600000", "900000", "1800000", "3600000"] // 4
                        summary: bind pollingPref.entry
                    }
                ]
            }
            PreferenceCategory {
                "Filter"
                def CLEAR = "\{Clear Filter\}"; // 5
                preferences: [
                    statusPref = ListPreference {
                        def status = [CLEAR, "HEALTHY", "WARNING", "DOWN"]; // 5
                        "Filter By Status"
                        key: "statusPref"
                        defaultValue: CLEAR
                        entries: status
                        entryValues: status
                        summary: bind if (statusPref.value == CLEAR) "Select a status to filter on." else "Current value: {statusPref.value}"
                    }
                    senderPref = ListPreference {
                        def senders = [CLEAR, for (s in ConnectionService.getSenderNameList()) s];
                        "Filter By Sender"
                        key: "senderPref"
                        defaultValue: CLEAR
                        entries: senders
                        entryValues: senders
                        summary: bind if (senderPref.value == CLEAR) "Select a sender to filter on." else "Current value: {senderPref.value}"
                    }
                    receiverPref = ListPreference {
                        def receivers = [CLEAR, for (r in ConnectionService.getReceiverNameList()) r];
                        "Filter By Receiver"
                        key: "receiverPref"
                        defaultValue: CLEAR
                        entries: receivers
                        entryValues: receivers
                        summary: bind if (receiverPref.value == CLEAR) "Select a receiver to filter on." else "Current value: {receiverPref.value}"
                    }
                ]
            }
        ]
    }
}

While I am not going to include the full original Android code (200 lines is a lot of code!), here are some of the changes that made the Visage version much more succinct (the below bullets match the numbers in the comments above):

1. The Visage object literal syntax is more concise than XML and just as readable!
2. Default properties make the object literal syntax even more concise
3. One bind call can replace dozens of lines of code to setup and instantiate event listeners
4. No need to declare arrays in a separate file (yes, we have real data types)
5. This is a real programming language, so you can use constants and variables to repeat arguments (try doing that in XML!)

All of the technology here is real, but getting a completed set of APIs that covers all of the things you can accomplish in Android is still a work in progress.

If you are interested in helping out with this, please join the Visage Developers mailing list.  I will be posting instructions there soon on how to access the bleeding edge Android Visage repository, and contribute to the growing set of Android APIs.