JavaOne 2012: The Road to Lambda

One of the presentations I most eagerly anticipated for JavaOne 2012 was Brian Goetz's "The Road to Lambda." The taste of Lambda at last night's Technical Keynote only added to the anticipation. Held in the Hilton Plaza A/B, this was a short walk from the previous presentation that I attended in Golden Gate A/B/C. I had expected the relatively large Plaza A/B to be packed (standing-room only), but there were far more empty seats than I had expected.

Goetz started talking about Java 8 being "in the home stretch," but not yet released or ready for delivery. He said he expects Java 8 and Lambda to be available about this time next year. Goetz said that you "can write any program that's worth it to write using Java," but that Java 8 will make it much easier to do so. His slide "Modernizing Java" talked about Java SE 8 "modernizing the Java language" and "modernizing the Java libraries." His last bullet on the slide stated, "Together, perhaps the biggest upgrade ever to the Java programming model." This has been my feeling and that's part of why I was surprised this presentation was not better attended.

Goetz stated that a lambda expression is "an anonymous method." It has everything that a method has (argument list, return type, and body) except for the name. It allows you to "treat code as data." A method reference references an existing method. Goetz reiterated the huge fundamental shift to writing and using libraries that will result from addition of lambda expressions.

Goetz pointed out that most languages did not have closures when Java started in 1995, but that most languages other than Java do have closures today. He then summarized some of the history of closures in Java in the slide titled "Closures for Java - a long and winding road." He referenced Odersky's and Wadler's 1997 "Pizza" (1997), Java 1.1's inner classes (1997), and the 2006-2008 "vigorous community debate about closures" (including BGGA and CICE). Project Lambda was formed in December 2009 and associated JSR 335 was filed in November 2010. It is "fairly close to completion" today.

Goetz stated that the for loop is "over-specified for today's hardware" while describing the "accidental complexity" associated with use of "external iteration" that we frequently use today. I agreed with the point he made that the "foreach loop hides complex interaction between client and library."

The goal of lambda expressions allows the "how" to be moved from the client to the library. Goetz emphasized that this is more than a syntactic change because the library is in control with lambda expressions and it is an internal iteration. Goetz stated, "The client handles the 'what' and the library handles the 'how' and that is a good thing." He added that lambda expressions have a profound effect on how we code and especially on how we develop libraries.

Goetz discussed the new forEach(Block) method added to collections using the new default implementation mechanism for Java interfaces. Goetz differentiated that Java has always had multiple inheritance of types (can implement multiple interfaces), is now (Java 8) going to have multiple inheritance of behaviors (default method implementation available for interfaces), but still won't have multiple inheritance of state (the last of which he describes as the most dangerous). Goetz had a slide dedicated to explanation of why "diamonds are easy" when you take date (state) out of the multiple inheritance.

Goetz had a nice slide summarizing "Default Methods - Inheritance Rules." This slide featured three rules. He pointed out that "if default cannot be resolved via the rules, subclass must implement it." Goetz pointed out that an interface could provide a "weak" default implementation and subclasses can provide better implementations.

Another advantage of default methods on interfaces is that the default implementation can throw an exception (such as UnsupportedOperationException) for optional methods so that subclasses not implementing the optional behavior don't need to do anything else. Goetz also showed how lambda expressions enable the addition of reverse() and compose() methods to Comparator.

Goetz showed several examples of code that illustrated that lambda expressions allow for "cleaner" and "more natural" representations. In his words, "the code reads like the problem statement" thanks to the composability of the lambda expression-powered operations. There is also "no mutable state in the client."

One of Goetz's slides had a quote I plan to use in the future: "Laziness can be more efficient." The context of this is that laziness can be more efficient if you're not going to use all of the results because you can stop looking once a match is determined. Stream operations are either intermediate (lazy) or terminal (naturally eager).

The Stream is an abstraction introduced to allow for addition of bulk operations and "represents a stream of values." Goetz's bullet cautioned that a Stream is "not a data structure" and "doesn't store the values." The aim here was to avoid noise in setting things up and try to be more "fluent."

Goetz stated that "one of Java's friends has always been libraries." He talked about how lambda expressions enable greater parallelism in the Java libraries. Goetz stated that fork-join is powerful but not necessarily easy to use. Goetz emphasized that "Writing serial code is easy; writing parallel code is a pain in the ass." Lambda expressions will still require parallelism to be explicit, but should be unobtrusive with lambda expressions and their impact on the libraries.

To emphasize Project Lambda's effect on parallelism in the libraries, Goetz showed a painful slide with how parallel sum with collections would be done today with fork-join and then another slide showing the much simpler use of lambda expressions. The point was made: much less code with lambda expressions, making the business logic a much larger percentage of the overall code.

Goetz introduced Spliterator as the "parallel analogue of Iterator." The Spliterator's prescribed behaviors are available to any object that knows how to split itself (Spliterable).

The slide "Lambdas Enable Better APIs" drove home the powerful and welcome effect of lambda expressions on the standard Java APIs. He emphasized that the "key effect on APIs is more composability.

Goetz stated that we typically prefer evolving programming model via libraries than language syntax for numerous reasons such as less cost, less risk, etc. He summarized his presentation by stating that times have changed and it is no longer a radical idea for Java to support closures.

One of the attendees asked why lambda expression method support is on the collections rather than on iterators. Goetz said that although C# did approach it from the iterator approach, his team found it less confusing for developers to have the methods on the collections instead of on the iterators.

In response to another question, Goetz stated that reflection on lambda expressions is not yet available due to its complexity. In response to another question, Goetz stated that lambda expression support is built with invokedynamic and method handles. This is part of an effort to make lambda expressions "fun to program" and "fast."

Another question led to a really interesting response from Goetz in which Goetz explained that the availability of internal iteration within a collection itself means the iteration complexity will be encountered by far fewer people (library developers rather than end user developers). Goetz encouraged attendees to run Java 8 drops currently available to help determine if Lambda expressions are being handled correctly. Goetz remarked, "The most valuable contribution we get from the community are people who say, 'I tried it out and found this bug.'"

Goetz started this presentation by stating that this was one in a long line of presentations at previous JavaOne conferences and other conferences on the state of lambda. What was different about this one, however, is that Project Lambda is "almost there" and, with that in mind, it seems that the syntax and concepts are largely in place. This obvious solidification of the APIs and syntax is welcome and this presentation met my very high expectations for it.

JavaOne 2012: How Do Non-Blocking Data Structures Work?

I was a little surprised when I looked at my schedule for today and noted that all of the sessions I have currently planned to see today are in the Hilton. This became a little less surprising when I realized that about half of the JavaOne presentations are in the Hilton and that they seem to be roughly located by track.

Tobias Lindaaker's (Neo Technology) presentation "How Do Atomic Data Structures Work?" was held in the Hilton's Golden Gate 3/4/5 conference room area. Lindaaker changed his presentation's title since he originally submitted the abstract. The abstract's title (and that listed in the conference materials) was "How Do Atomic Data Structures Work?," but he has renamed it to "How Do Non-Blocking Data Structures Work?"

Lindaaker explained that "atomic" comes from Greek and meaning "undividable." He explained that a "lock-free data structure" is "a data structure that does not block any threads when performing an operation on the data structure (read or write)." He stated that one wants to avoid "spin-waiting" whenever possible.

Lindaaker talked about synchronized regions. He said such regions "create a serialized path through the code" and "guarantee safe publication." He defined "safe publication" as meaning "everything written before exiting synchronized [block]" and "guaranteed to be visible on entry of synchronized [block]." One of his bullets stated, "volatile fields give you safe publication without serialization." Lindaaker focused more on the volatile keyword modifier in his "volatile fields" slide.

The slide "What is a memory barrier?" provided a simple visual representation of the memory barrier concept.

For his slide "Atomic updates," Lindaaker stated that the easiest way to access an atomic reference is via use of java.util.concurrent.atomic.AtomicReference<V>. Lindakker provided a physical demonstration using coasters to illustrate the difference between compareAndSet (sets a value if the conditional matches favorably) and getAndSet. (sets new value returns old value).

Lindaaker prefers java.util.concurrent.atomic.AtomicReferenceFieldUpdater<T,V> because of its "lower memory overhead" ("fewer object headers") and "better memory locality" ("no reference indirection").

Lindaaker explained that array-based queues do block (sometimes a benefit when amount of work needs to be limited due to finite hardware resources), linked queues do not block. Lindaaker used a supermarket queue as an example of the differences. In the link-based queue, you always stand behind the same customer in front of you in the queue. In the array-based queue, you always remain in the same position. Bounded queues "frequently perform better," but will block when full.

One of the main themes of this presentation was the idea of learning new ideas and then individually researching them further. Lindaaker recommended that audience members look at the JDK's code to see some impressive and less impressive code examples.

Lindaaker referenced LMAX (London Multi Asset Exchange) Disruptor as an example of a "ring buffer" ("array with a read mark and a write mark"). He stated that "readers contend on the read mark, writers on write mark" and highlighted the consequence of this, "With single reader / single writer, there is no contention." The Disruptor page describes Disruptor as a "High Performance Inter-Thread Messaging Library."

Lindaaker stated that java.util.concurrent.ConcurrentHashMap is a good general choice, but is not very exciting for discussion in his presentation. He stated that it "scales reasonably well on current commodity hardware" (fewer than 100 CPUs) with proper tuning.

Neo Technology provides a database implementation (Neo4j) that is not relational (graph database). Lindaaker described the Neo Technology's graph-based database offering as, "Stores data as nodes and relationships between nodes."

JavaOne 2012: JavaOne Technical Keynote

Mark Reinhold started off the JavaOne 2012 Technical Keynote. He said this year's edition would be a little different because it would use largely the same example to illustrate various aspects of Java rather than standalone individual coverage of each component of Java. Richard Bair and Jasper Potts of the JavaFX team (and associated with FXExperience) introduced this example application, a schedule builder with presentation and speaker data from this year's JavaOne.

As part of the introduction of the example application, the presenters made extra effort to point out that Oracle is shipping the JVM for MacOS and that OpenJDK is what is being used in the example. They also stated that the example runs on Linux as well. They used Java SE 7 and JavaFX 2 for this application and they talked about the availability of SceneBuilder for building a JavaFX application. They demonstrated the use of SceneBuilder within NetBeans to generate the JavaFX-based login page.

Other interesting JavaFX advancements mentioned include the addition of a ComboBox (though there is no Date Picker yet), interoperability with SWT, and the availability of a JavaFX Packager. It was also mentioned that JavaFX was architected and designed from the beginning to allow for the main UI thread to be separate from background threads, allowing it to take advantage of multiple CPUs.

Bair showed the relatively verbose code that would be required to implement a JavaFX application to fully take advantage of multiple threads today. Brian Goetz came to the stage to describe how Project Lambda and the changes to the Java language will enable "better parallel libraries." Goetz said that the easiest way to help developers is to give them better libraries, but the language must sometime be extended when the limits of the language prevent libraries from being written to fully satisfy the need.

Goetz stated that the goals of inner classes are the same as Project Lambda, but inner classes have "a whole lot of other baggage." Goetz added that bulk operations on collections may not "really be needed, but things are better this way." Goetz then showed a simple but highly illustrative example of how Project Lambda changes how we process bulk data changes in a collection. His slide showed the J2SE 5 enhanced for loop is used today but can be done with the forEach method (added to all of the collections via the new default implementation interface approach) and a Groovy-like closure syntax (->).

Goetz's next slide was even more impressive. He showed what appeared to be three operations being performed on a collection as it was iterated. However, he pointed out that these would all be enacted at once on the collection with only a single traversal of that collection. All I could think was, "Wow!" Goetz also had a slide showing off the computeIfAbsent operation on collections. He ended by saying there's still lots of work to do and citing two URLs for playing with Project Lambda: http://openjdk.java.net/projects/lambda/ and http://jdk8.java.net/lambda/.

There was some interesting discussion on the differences between traditional Java environments and embedded environments. Raspberry Pi received multiple and prominent mentions.

Reinhold started talking about modularity and Project Jigsaw and showed a "little bit of a spaghetti diagram that is way cleaner than where we started, which was a total spaghetti diagram." He used this as a starting point for discussing the controversial decision to boot Project Jigsaw from Java 8 to Java 9.

Reinhold had a slide focused on things that are in Java 8 such as Project Lambda, Compact Profiles, Type Annotations, Project Nashorn, and the new Date/Time API. Reinhold added that "all this work is being done in OpenJDK" and that "all the specification work is being done in the JCP."

Arun Gupta had the unenviable task of beginning his presentation at the time the keynote was scheduled to end (7 pm local time). He talked about Java EE and showed a slide titled, "Java EE Past, Present, & Future." This slide showed how Java EE has added features since the ten specifications of J2EE 1.2 in December 1999. Gupta had another slide talking about "Java EE 7 Revised Scope" and how it increases productivity (via less boilerplate code with richer functionality and more defaults) and adds HTML5 support (WebSocket, JSON, and HTML5 Forms).

Another Gupta slide was titled "Java EE 7 - Candidate JSRs" that listed JSRs that are all new to Java EE 7 as well as those being modified. He then focused individual slides on some of them. His "Java API for RESTful Web Services 2.0" slide talked about a standarized approach using a client API. Gupta's slides showing how this is done today (without libraries) and comparing it to the next client API demonstrated how much simpler this is going to be.

Gupta's coverage of JMS 2.0 included discussion of less verbosity in JMS thanks to annotations and other new features in the Java programming language. He mentioned that the required resource adapter will make it easier to "mix and match" JMS providers in the future. Gupta showed a slide full of small-font code ("this code is not meant to be readable") demonstrating sending a message using JMS 1.1. This was followed with a slide showing significantly less (and much clearer) code in JMS 2.0 taking advantage of annotations and resource injection to send a message.

Gupta's coverage of the JSON support to be added to Java EE included the bullet "API to parse, generate, transform, query, etc. JSON." He then showed some slides with example JSON-formatted data and example code for using builder-style to access the JSON. It felt a lot like Groovy's JSON handling.

Java API for WebSocket 1.0 will allow annotations to be used to easily work with WebSocket. When covering Bean Validation 1.1, Gupta pointed out that not all new adopted JSRs are being led by Oracle. He showed using the built-in @NotNull annotation on method parameters, but also showed that one will be able to write custom constraints that can be similarly applied to method arguments.

Gupta highlighted miscellaneous improvements to Java EE such as JPA 2.1, EJB 3.2, etc. The majority of these JSRs have early public drafts available. GlassFish 4 is the reference implementation of Java EE 7 and already includes WebSocket, JSON, JMS 2, and more.

One of Gupta's slides was focused on Avatar. The "Angry Bids" example application was demonstrated. It is based on Avatar and runs on GlassFish and uses standard Java EE 7 components.

Gupta introduced Project Easel for NetBeans. It was mentioned that NetBeans 7.3 beta would be coming out later this week and will include support for HTML5 as a new project type. The example being showed uses JQuery and CSS. The NetBeans-based example communicated through Google Chrome to WebKit (it also works with the JavaFX-embedded browser), but it is expected to work eventually with any WebKit-based browser or device. The demonstrator showed how his changes to HTML5 code (HTML, JavaScript, and CSS) within NetBeans were updated in the Google Chrome browser. It was pretty impressive and makes me wish I had enough time to have accepted an invitation to provide early testing of NetBeans 7.3. NetBeans is going to be able to generate RESTful clients, support JQuery, and provide a Project Nashorn editor. A similar demo to this one is available at http://netbeans.org/kb/docs/web/html5-gettingstarted-screencast.html.

Like the Strategy Keynote, this Technical Keynote was held in the Masonic Auditorium. One of the interesting trends I noticed in tonight's keynotes was that at least three different people from three different organizations mentioned looking for skilled Java developers should contact them if interested in job opportunities.

JavaOne 2012: Java Strategy Keynote and IBM Keynote

I had a rough start to JavaOne 2012 similar to that at JavaOne 2010. It took 70 minutes for the people handling the check-in to provide me with a JavaOne badge due to "computer and printer technical difficulties." Although I'm not the most patient person in the world, the part of this that was even more disappointing than the wait is that I missed being part of the "Community Session: For You - By You: Growing the NetBeans Community" panel at NetBeans Community Day at JavaOne 2012, something I was really looking forward to attending and participating in. I had arrived at Moscone West about 15 minutes before that panel was to begin, but did not end up getting my badge until well after the panel was over. In a disappointed mood, I headed to the Nob Hill Masonic Center (AKA Masonic Auditorium, AKA California Masonic Memorial Temple) on Nob Hill to attend the initial evening's keynote address.

Java Strategy Keynote

The first announcement was to "turn off all electronic devices." After that announcement, a video was shown. I was happy that it was short. Hassan Risvi introduced the theme for JavaOne 2012: "Make the Future Java." He showed slides indicating the 2012 Scorecard for three areas of Java's strategy: technical innovation, community involvement, and Oracle leadership.

Georges Saab stated that Oracle has made Java available for more new platforms in the past year with JDK 7 than added in the previous ten years. He highlighted JDK 7's adoption and talked about OpenJDK. One feature of JDK 8 that he highlighted is Project Nashorn, a JavaScript implementation taking advantage of invokedynamic for high performance with high interoperability with Java and the JVM. He announced that Project Nashorn will be contributed to OpenJDK. He stated that IBM, RedHat, and Twitter have already expressed support for Project Nashorn as part of OpenJDK.

Dierk König of Canoo and Navis were guest speakers at this Strategy Keynote. They talked about their use of JavaFX and the Canoo Dolphin project being open sourced.

Nandini Ramani talked about JavaFX and stated that its now available for all major platforms. She also cited the release of NetBeans 7.2 with integrated SceneBuilder as part of improved tooling. She also reminded the audience that JavaFX is now bundled with current versions of Java. Ramani announced that JavaFX is now available for Linux ARM. She mentioned that 3D is coming to JavaFX. It was also mentioned in this keynote that they expect JavaFX to be fully open source by the end of the calendar year.

AMD's Phil Rogers talked about hardware trends moving from single-core CPUs to multi-core CPUs to GPUs using "a single piece of silicon and shared memory." Saab and Rogers stated that Project Sumatra allows the JVM to be modified so that Java developers can take advantage of new features in the hardware with existing Java language skills. The JVM will be able to decide whether to run the Java code on a multi-CPU or multi-processor.

Ramani returned to the stage and mentioned two new recently announced releases: Java ME Embedded 3.2 and Java Embedded Suite 7.0. Axel Hansmann of Cinterion talked about his company's use of Java ME Embedded.

Marc Brule of the Royal Canadian Mint joined Ramani on stage to talk about their use of Java Card: MintChip ("The Evolution of Currency").

Cameron Purdy came to the stage to discuss Java EE. Purdy announced that the earliest releases of Java EE 7 SDK can be downloaded via GlassFish versions. Purdy also announced that GlassFish 4 already includes significant HTML 5 additions mentioned at JavaOne 2011. Purdy pointed out that NoSQL is not standardized yet ("you could call it 'No Standard Databases'") and pointed out that JPA already supports MongoDB and Oracle NoSQL with planned support for Cassandra and other NoSQL implementations. Purdy stated that April 2013 is the currently planned timeframe for release of Java EE 7.

Nicole Otto of Nike joined Purdy on stage and showed a brief video (FuelBand: "Life is a Sport: Make It Count"). She talked about Java EE being used to track data on activity. Purdy had a slide "Java EE 8 and beyond" that was sub-titled: "Standards-based cloud programming model."

A short film was shown to introduce Dr. Robert Ballard (now I know why we were given the Alien Deep DVD upon entrance to the keynote). Dr. Ballard talked about his discovery of the Titanic and explained how the technology used for that discovery was like tying two tin cans together compared to the technology available today. The most laughter and applause of the night came to his statement that he hoped to find a spaceship in his explorations so that he never has to talk about discovering the Titanic again. Dr. Ballard stated that we should not sell science or engineering but should make it more personal to kids and sell scientists and engineers. He stated that "the battle for a scientist of engineer is over by the eighth grade."

IBM Keynote: (hardware,software)–>{IBM.java.patterns}

We moved, without break, directly into the IBM Keynote. Jason McGee (blog), an IBM representative, talked about "some of the things we've seen related to Java and the cloud." He talked about "Java Challenges" as "share more," "cooperate," "use less" (resources), exploit technology. John Duimovich came to the stage to talk more about these four challenges "in context on the Java Virtual Machine."

Duimovich talked about "shared classes cache" and AOT (Ahead of Time), described as "JIT code saved for next JVM" to use. Duimovich also talked about multi-tenancy and supporting "isolation within a single JVM." He had a slide on the Liberty Profile "for Web, OSGi, and Mobile Apps."

Duimovich introduced "really cool hardware" called System z and explained the advantages of running Java (rather than C or C++) on this hardware. Duimovich stated that "Oracle and Java team together on Java, but compete head to head." He pointed out that this "competition drives innovation" and is good for customers and developers.

McGee returned to the stage to talk about a few more themes, observations, and trends. He pointed out that "Java provides developers abstraction from underlying hardware," but that "hardware is changing and evolving rapidly." McGee's slide stated that "both Java and Cloud need to enable the exploitation of these hardware advances while still preserving the 'run anywhere' benefit."

Another McGee slide was titled "Java in a ploygot world..." and he used this slide to talk about the world transitioning from an all-Java enterprise world to today with applications written in numerous languages. He mentioned several alternative JVM-based languages and put a plug in for IBM's X10 language. McGee believes that Java will be part of, but not all of, future enterprise applications.

Packt Publishing's 1000th Title: Surprise Gifts

Packt Publishing published its first book in 2004 and is about to publish its 1000th book. Along the way, Packt Publishing has donated a portion of revenue to the open source projects covered by its books. As part of their celebration of publishing their 1000th title, Packt Publishing has a "surprise gift" for anyone who has registered with them or has an account with them on 30 September 2012.

This is the information Packt Publishing provided to me related to this celebration:

To celebrate this event with our readers, we'd be gifting them with not one but two assured surprises which would be revealed to them by the 30th of September, 2012. Anyone who is already registered or signs up for a free Packt account before 30th September 2012 is guaranteed a surprise gift.

I have received electronic copies of Packt Publishing books in the past as part of book reviews. The books I reviewed are JBoss AS 7 Configuration, Deployment and Administration, Java EE 6 Cookbook for Securing, Tuning, and Extending Enterprise Applications, and Java EE 6 Development with NetBeans 7. In addition, I have purchased three electronic books from Packt Publishing (Groovy for Domain-Specific Languages, Learning jQuery, and Java 7 New Features Cookbook).

Packt Publishing has offered me an electronic book for promoting this celebration event and I am having a difficult time choosing from many selections that look interesting including Grails 1.1 Web Application Development, GlassFish Security, Java 7 Concurrency Cookbook, Akka Essentials, and Java EE 6 with GlassFish 3 Application Server.

JavaOne 2012 Announcements and Blog Postings

In the blog post Where's Ed at JavaOne 2012, JavaServer Faces specification lead Ed Burns points out that "JavaOne 2012 is just 19 business days away!" In that post, he shows a screen snapshot of the Google Calendar representation of his schedule for JavaOne 2012. With a slightly more than 4 weeks to JavaOne 2012, the posts and announcements related to "the biggest geekfest this side of Betelgeuse Five" are becoming more frequent and I look at some of those here.

NoSQL and Data Grids

Manik Surtani is the one calling JavaOne 2012 "the biggest geekfest this side of Betelgeuse Five" in the post JavaOne 2012, here I come. In that post, he discusses his Birds of a Feather presentation BOF5866 - JSR 347, Data Grids, and NoSQL and his Conference Session CON5875 - Making Apps Scale with CDI and Data Grids.

JSF and Java EE

In the previously cited Ed Burns post, he covers what he is attending and supporting at JavaOne 2012. These include manning the Java EE booth and attending/giving several presentations related to JSF.

OpenJDK

In his burek for breakfast blog post JavaOne 2012: OpenJDK Edition, Dalibor Topic observes a sort of Moore's Law-inspired "robilad's Law": "the number of sessions on OpenJDK at JavaOne keeps approximately doubling since 2009." He lists 19 sessions at JavaOne 2012 associated with OpenJDK.

NetBeans

As I wrote in a recent blog post, the NetBeans Community Day at JavaOne 2012 Conference has been announced. A collection of JavaOne 2012 sessions focused on NetBeans is available in NetBeans at the JavaOne 2012 Conference.

Mark Stephens has also written about the NetBeans Day at JavaOne 2012. About NetBeans, Stephens writes, "NetBeans has seen a huge amount of development in the last 12 months. ... And NetBeans provides far more than just an IDE to write Java code."

Java Champions

Markus Eisele has written about the Java Champions at JavaOne 2012. He breaks down sessions presented by Java Champions and Java Champion Alumni (those now working for Oracle).

JavaOne 2012 Keynotes

The JavaOne 2012 Keynotes have been announced. The Java Strategy Keynote, "Oracle's Java engineering luminaries will demonstrate Oracle's continued commitment and positive stewardship of Java, as well as provide a glimpse of the future which showcases the vast opportunities that Java provides." The listed "luminaries" are Cameron Purdy, Nandini Ramani, Hasan Rizvi, Georges Saab, and Henrik Stahl.

The Technical Keynote, often my favorite of the JavaOne keynotes, at JavaOne 2012 has the objective of "offer[ing] an integrated look into how the entire range of the Java portfolio is evolving to offer developers a high-performance, standards-based platform to meet the challenges of the next generation of enterprise computing." It's listed speakers are Richard Bair, Terrence Barr, Arun Gupta, and Mark Reinhold.

The Strategy Keynote and Technical Keynote open JavaOne 2012, but the Java Community Keynote starts the final day of the conference. This keynote focuses on the Java community and "will showcase several Java community luminaries and their bodies of work." The two listed to introduce these "community luminaries" are Sharat Chander and Donald Smith.

NetBeans Community Day at JavaOne 2012

Geertjan Wielenga invited me to participate in the panel at NetBeans Community Day at JavaOne 2012 and I'm looking forward to that. I'll be participating in the "Community Session: For You -- By You: Growing the NetBeans Community" (UGF10364) discussion that is scheduled for 30 minutes from 2 to 2:30 pm on 30 September 2012 (just before the conclusion/wrap-up session).

The main topic of conversation in the "Community Session: For You -- By You: Growing the NetBeans Community" session definitely interests me and can be summed up as a discussion on "the various ways to keep the NetBeans community vibrant and to leave your mark on the [NetBeans] project." Those who submit patches and create plug-ins for NetBeans are obviously very significant to its success. However, I like that this session recognizes that there are numerous other ways to contribute to open source including "blogging, setting up user groups, organizing seminars or creating YouTube videos, and more." The session description makes a very important observation: "Regardless of programming expertise, there's something for everyone to do." I'll be specifically talking about writing about NetBeans on this blog.

There are several sessions focused on NetBeans and the NetBeans community at NetBeans Community Day at JavaOne 2012. These include the NetBeans Community Keynote (UGF10353), NetBeans and Java EE (UGF10361), NetBeans and Java FX (UGF10362), NetBeans Platform (UGF10363), and the "Closing/NetBeans Awards/Community Recognition."

The NetBeans Community Day at JavaOne 2012 page also links to a page with sessions of JavaOne 2012 with a NetBeans focus or emphasis. This page, NetBeans at the JavaOne 2012 Conference, lists approximately 30 sessions with a NetBeans emphasis.

One of the hallmarks of a strong open source project is its community and I look forward to learning more from fellow members of the NetBeans community.