This talk covers the various things I’ve learned about leading a Java User Group over the past few years. I would say that these are definitely applicable to leading any type of user group, so even if you aren’t a Java person, you might find some meat here. Enjoy!

General Session Replays: http://java.sun.com/javaone/2009/general_sessions.jsp

BlogTalkRadio: http://www.blogtalkradio.com/JavaOne

JavaOne Minute: http://channelsun.sun.com/video/channel-you/javaone+minute/23867338001

Technical Sessions 2008-2009: http://developers.sun.com/learning/javaoneonline/ (Must be SDN Member – FREE!)

The Da Vinci Machine Project: http://openjdk.java.net/projects/mlvm/

Groovy: http://groovy.codehaus.org

Java.net Community Corner: http://wiki.java.net/bin/view/Javaone/CommunityCorner

JUGS Community: http://community.java.net/jugs/

Scala: http://scala-lang.org

SpringSource: http://www.springsource.com

JUG-USA: https://jug-usa.dev.java.net/

OpenSolaris: http://opensolaris.org

Neal Ford: http://nealford.com (Can download his slides here)

Findbugs: http://findbugs.sourceforge.net

Grails: http://grails.org

Grails Podcast: http://www.grailspodcast.com

JavaFX: http://javafx.com

Griffon: http://griffon.codehaus.org

Java Store: http://store.java.com

Jython: http://jython.org

Clojure: http://clojure.org

JRuby: http://jruby.codehaus.org

Sun Cloud: http://cloud.sun.com

Project Kenai: http://kenai.com

Zembly: http://zembly.com

NetBeans: http://netbeans.org

The session was setup as an informal Q&A. I took furious notes on several of the questions that were most interesting to me, and I’ll do my best to collate them into something intelligible here. Note that where I use quotes it’s mostly to set off his answers…please don’t take them as direct, but as paraphrases.

The first couple of questions surrounded web buzz. James sees Web 2.0 as “hype for folks who want to sell their books.” When asked about the semantic web, he says his feelings are mostly positive, but maybe its an answer searching for a question. He feels that some parts of it will never perform.

When asked about Scala, I was pleased to hear him say, “I like Scala a lot. They’re doing some pretty nice stuff.” He talked about how functional languages lend themselves to proving properties of programs, which can then lead to automatic decomposition onto multiprocessor systems. He wishes that the Scala guys would focus more on this aspect. He also said that he fears that Scala is almost going down the Perl route of making things “too concise” and that it’s still awfully hard for many programmers to “get” the functional stuff.

The next question was a rather predictable one – “James, now that you have the benefit of 14 years of experience with the Java language, is there anything you would have done differently?” Funny thing was the first thing out of his mouth was that the current AWT event model would have been one of the first things to go. Generics and closures were things he quickly mentioned that he wanted to have done, but he also said that there was quite a bit of arguing within the Java team about polishing for years vs. shipping the language. James said he felt like there was a certain window of opportunity out there that they needed to ship the language within to be successful (and it looks like they hit it). Continuing on down the list, James mentioned Eiffel-style precondtions and postconditions and type inferencing. He explained that the entire type system was designed to make C programmers comfortable, and at the time that was clearly the right decision. He state that at this point, the C/C++ comfort factor counts for nothing, and remarked that the casting syntax in Java is just “dumb.” A follow-up question surrounded whether or not primitives should be a part of the language. James called this a hard problem, asserting that a “uniform type model can lead to bumpy behavior or bad performance.” He said that the Scala specification gets around this with a dual object hierarchy (I need to look this up to see what he means.). He continued to talk about the definition of equality vs. identity, explaining that primitives can’t have identity; in fact, they may never exist except as a figment of the compilers imagination, optimized away (my notes are fuzzy on this…when I get the recording I’ll clean this up).

The next question surrounded a statement that one attendee of the recent Google I/O conference heard, that threads are “deprecated” as a concurrency model. James immediately retorted that concurrency has very many ideas around it, and that it has been an active Ph.D. thesis generator for 30+ years. He mentioned competing models such as Actors in Scala and Erlang, and Communicating Sequential Processes (CSP) process algebra from Occam. He asserted that with CSP most people typically don’t “think that way very well. People with Math degrees think it’s cool, but everybody else is kind of like…huh?” He stated that no data sharing between threads makes a lot of problems go away, but that often times casting problems that way can be intractable. A big quotable: “All of the different threading paradigms feel to me like whack-a-mole.” He closed the concurrency question by mentioning Guy Steele’s work on Fortress, where they are doing automatic decomposition from functional constructs into multiple threads of execution, making all of this issue transparent to the programmer.

Since this is getting pretty long, I’ll mention that James says he knows that Larry Ellison, Oracle CEO (and Sun “suitor”) has downloaded JavaFX and personally written apps with it, saying it is “pretty darn tasty!” (Again, don’t take this as quoted…it’s definitely paraphrased).

Other quotables: “Android – it’s hard to know what to think about it. It seems like a corner hobby project, chaos looking for a place to happen.”

“The exception system was DESIGNED to be a complete PITA.”

All-in-all, a great time was had by all. Thanks James for your time, it was definitely fascinating hearing your thoughts on so may different areas of the Java landscape.

I also finally got the chance to meet Dick Wall of the Java Posse. Dick is just as great in person as he has sounded for the past couple of years on the podcast. Unfortunately our chat was ever so brief, focused around the language features Dick would like to see in future versions of Scala. We were quickly ushered over to the Java.net “presentation area” to participate in Josh Marinacci’s JavaFX Q&A. Was also good meeting him and seeing the cool new UI controls in FX.

1. Demonstrating Language Features
2. Demonstrating Community Contributions

Each of the players focused on different angles during the language feature round. The Jython focus was squarely on the readability of the language. Frank’s key quote was Python looks an awful lot like “executable pseudocode.” The Groovy focus was a subset of Guillaume’s “What’s new in Groovy 1.6″ talk, and highlighted the new compile-time metaprogramming/AST transformations. Rich Hickey directly attacked concurrency using Clojure, demonstrating a multi-threaded “Life” demo that highlighted the power of software transactional memory.

I really enjoyed Dick’s angle for Scala – demonstrating that most of the Java small language changes contained in Project Coin are already present in the Scala language and very useable! Thomas Enebo went straight for the WOW factor by showing how easily a Ruby DSL can be wrapped around existing Java libraries with JRuby to create a very compelling 3D game.

Next came the community round. This was actually the most impressive part of the whole session. Frank kicked off the Jython community focus by highlighting an interactive “art IDE” called Field that drives the Processing language. The chose Jython as the scripting language for the environment. Very neat.

The Groovy demo was something to behold. Guillaume started off by demonstrating SwingPad, an exploratory IDE for building Swing applications with Groovy. But the real treat was a very impressive Twitter+NASA Worldwind mashup built very concisely using Griffon. I really need to give Griffon a try.

Rich Hickey demonstrated the power of Clojure to build a data-driven, functional, template based website. It took an existing HTML template (with 0 code) and transformed it using “css-like” selectors provided by a enlive. Seemed a lot like what you can do with XSLT, but much cleaner.

Dick demonstrated scouchdb, a Scala library for interacting with CouchDB.

Thomas’ focus was on just how big the Ruby community is, from developers, to conferences, to books, to IDE’s, to libraries.

At the end of the session, the winner was decided by crowd noise, with Groovy winning the day and Scala coming in second. My take home from this session is that really all of these languages bring something very interesting and powerful to the table, and I hope all of them continue to succeed. Great job everyone!

Things kicked off very slowly. Jonathan Schwartz, Sun CEO, for all of his ponytail excellence, wasn’t exactly inspiring a great deal of excitement in the crowd. In fact, the loudest applause from the audience was initially for the tech support guy who fixed the projection for one of the demos.

Thankfully things eventually got moving. Verizon and Sun announced a very exciting partnership whereby Verizon will expose their network elements to Java developers. Things like presence, location, friends and family lists, mobile-to-mobile lists – all of these will now be accessible to the developer. These specs will come out on July 27. This announcement is very exciting as it means that Verizon phones will now be a very powerful platform for Java mobile development.

The JavaFX demos were really cool. They demoed one of the new LG XCanvas series of TV’s, which actually run JavaFX on the TV itself. Processors and video codecs actually live within the TV, and the TV is connected to the network. Live, on-demand, interactive content is now available directly on the set, and it’s very smooth. It seems that JavaFX continues to be the center of innovation within Sun. This continued with a demo of the new JavaFX visual authoring tool. This was very impressive. JavaFX apps are now possible with absolutely no coding, which makes them extremely accessible to content designers. Visual assets can be dragged and dropped onto the stage, animation can be built by recording drag motions, no compile-build-deploy cycle. Another great features was visual wiring of component properties to UI controls. Very smooth. And apps can be deployed directly to the Java App Store via the tool.

Funny, this was the big oops of the keynote. Nandini Ramani leaked the “liveness” of the app store before the official announcement. Nandini – “And you can deploy directly to the App Store.” Jonathan – “We haven’t launched the App Store yet.” OOPS.

But the App Store was immediately announced next. http://store.java.com is now in private beta, and I quickly registered and got an invite. I was playing with the App Store in the following session and downloaded two applications. Extremely like the iPhone App Store for Java. You can now distribute your Java applications directly to billions of consumers with Java-enabled devices. At this point it only supports free applications, as they have left it up to the community to provide feedback on how money should be collected. Nice move. Very impressive. This could be a game changer for the Java platform if it’s used correctly.

FINALLY the elephant came out, but it took Scott McNealy coming on stage to get it done. It was very interesting how Jonathan Schwartz unceremoniously left the stage. Scott thanked him twice for his stewardship of the company – it was a very obvious yet implicit changing of the guard. Funny that they should decide to introduce Larry Ellison, CEO Oracle, via a great amount of cheesy images (Java flying on the sail to Larry’s yacht, etc.) At the end, while no promises were made, Larry said that we should look to the past to see what the future will hold and expect more of the same. “I don’t expect any significant changes.” I hope that holds true. The audience very properly gave Scott a standing ovation as he left the stage, a nice gesture to a guy that has continually kept Sun on the cutting edge of technology.

All in all, it was a bittersweet keynote, but I’m cautiously optimistic about the future of the platform. Our landscape is continually changing, and the future is uncertain. If everyone’s being transparent, however, good things are still to come.

What exactly is Google App Engine? It’s none other than a way that you can run your Java™ technology-based applications on Google’s massive infrastructure.

As far as the “Geekxecutive Summary,” Google has provided:

• A Java 6 Virtual Machine with a Class Whitelist. Not all classes in the standard JDK library are available. A notable missing member is the java.awt.* library, so if you’re using that for image processing, find an alternative (see one later) before porting to the App Engine.
• The Java Servlet Standard by way of the Jetty container.
• A secured sandbox environment, meaning 1) no spawned threads; 2) no arbitrary socket connections (you can use HTTP/HTTPS, see below); 3) No writing to the local filesystem – makes sense because you don’t know where you are on any given request.

Several services are provided to you by Google as a Java developer:

• The Datastore – a schemaless object datastore, with a query engine and atomic transactions. This is accessible via Java Data Objects (JDO) 2.3, Java Persistence API (JPA) 1.0, or Google’s own low-level API’s.
• A Memcache service for caching whatever objects you like, accessible via JCache JSR 107.
• A URL fetch service for accessing data on other systems, accessible via java.net.URLConnection.
• A Mail (JavaMail) service.
• An Image processing service, a likely candidate for replacing AWT for image processing. Be careful, it binds you to Google’s services. You may want to write a wrapper for it.
• Google Accounts for authentication. Should you leverage this, anyone with a Google account can authenticate into your app.

The nice thing about Google’s services is that where possible they always provided a way in through standards-based Java API’s.

Now, on to tools:

• An Apache Ant component for your automated build process.
• A very nice plugin for the Eclipse IDE.
• The App Engine SDK – Java API’s into all of Google’s services.
• A Development Server so that you can run a simulated Google environment on your local machine.
• AppCfg for command-line interaction with the App Engine platform.

Probably the most significant piece to this puzzle is the fact that Google is not simply supporting Java the language, but Java the platform. It’s a standard JVM, so other languages running on the JVM will happily run on Google App Engine as well. At this writing, I knew of the following languages that are known to run:

• Java
• Groovy (and Grails as of 1.1.1)
• JRuby
• Scala
• Clojure
• Beanshell
• JavaScript (Rhino)
• Jython

Here’s the screencast from my talk. Enjoy!

For the uninitiated, Grails is a Ruby on Rails inspired full stack web development framework which brings “convention over configuration” and “DRY” into the Java web development arena. Unlike Rails, it is not an effort from scratch, but rather stands on the shoulders of proven giants in the Java world like the Spring framework and Hibernate. It does this using Groovy, the popular dynamic scripting language for the JVM, as a sort of “DSL for web development.” Find it at http://grails.org.

Morph AppSpace on the other hand is a fully-configured and managed environment for hosting web applications, and currently supports Java, Grails, Rails, and PHP applications. It is a “platform as a service” (PaaS) provider that abstracts away the details of Amazon EC2 and S3 technologies. Systems architecture, backups, monitoring, failover, scalability – all of this is handled by Morph. You simply develop and deploy your application – Morph does the rest. Find it at http://mor.ph/products_appspace.

So to get going, visit http://mor.ph and sign up for a free developer account. Create yourself a Java application subscription, and pick your choice of database (MySQL or PostgreSQL). Create the database, and then download two very important files into the root directory of your Grails project: deployment.properties, which contains the metadata describing your application to the Morph AppSpace platform, and morph_deployer.jar, which contains the client API to the platform.

Next you’ll need to install the Grails morph-deploy plugin. If you’re using Grails 1.1, you’ll need to checkout the trunk version from SVN, as the version in the plugin repository is not 1.1 ready. Install this plugin locally by running “grails install-plugin $PATH_TO_PLUGIN.” Next, you’ll need to edit DataSource.groovy to contain the following:

production {
        dataSource {
            driverClassName = 'com.mysql.jdbc.Driver'
            dbCreate = "update"
            jndiName = "java:comp/env/jdbc/morph-ds"
            dialect = 'org.hibernate.dialect.MySQLDialect'
        }
}

Finally, run “grails war” to build the war file, and “grails deploy” to upload your application to the platform. Once the upload is complete, visit the management interface and check the logs to see that you’ve successfully deployed. Once it’s finished, click on the link to your application. Happy Grails on the cloud!

Here’s the screencast from my talk. Enjoy!

• Finally met Aaron Houston and Mark DeHart from Sun JUG Programs. These guys have supported the Memphis JUG from the very beginning and have kept us supplied with tons of cool swag, as well as a Sun SPOT that continues to be a hit. Great guys.
• Briefly chatted with Carol McDonald from Sun. She was our very first JUG speaker and also had an extremely stressful encounter with our then new projector.
• Got to catch up with Keith Donald of SpringSource on what he’s been up to with Spring and what we’ve been up to with our SRM project. Keith joined us for a week long consulting engagement earlier this year and fit in like another member of the team. He and Oleg Zhurakousky covered the JUG meeting that week as well and we had our largest attendance ever.
• Finally met Van Riper, the man behind JUG-USA.
• Had a great dinner conversation with Abdel Remani, student JUG leader from California State University, Chico.
• Got to catch up with Dave Booth, formerly the JUG program guy from JetBrains, now with GravityGears.
• Briefly chatted with Wayne Fay, one of our former JUG members now working in San Francisco.

All in all it has been wonderful getting to connect with all of these folks, put faces to names, and share updates. Come to JavaOne. You get to meet neat folks!