CommunityOne opened with a keynote from Ian Murdock, VP of Developer and Community Marketing at Sun Microsystems. Ian feels that the software industry is undergoing a fundamental change, specifically in the area of open source. According to Ian, the software development industry is currently moving from a more proprietary based world, where innovation only happens in specific places (large companies), to more of an open, community engaged world, where innovation happens everywhere. He sees the industry starting to adopt a model that could be compared to a Linux distribution. Smaller, loosely joined software components (web services, packages, etc) developed by a community combined into a larger, functional unit that is greater than the sum of its parts. Ian stressed the importance of community involvement if this model is to succeed.
After Ian’s presentation, a moderated Q and A session was held with a group of individuals with senior roles at some of the larger companies that profit from open source products (MySQL, RedHat, etc), as well as groups that do not profit from their projects (Samba, Python, etc). The questions all revolved around how those people engage their communities, encouraged contributions, and grow their community as a whole. For the people who were associated with a company that profits from open source, questions were also asked regarding how to encourage contribution from their communities and give back to their communities, while still trying to turn a profit and satisfy their investors.
The theme of community was obvious. In the keynote, and in all of the talks that would follow at CommunityOne.
The Road to Babel: Bringing JVM Machine Implementers Together
Probably one of the best talks of the day, in my opinion. Charlie Nutter did a great job running down some of the popular and not so popular languages that can run on the JVM. He said that virtually every language that he knows of can run on the JVM one way or another. It is clear that Sun is working hard to reach out to these language implementers to beef up support for their languages on the JVM. There is also an effort among the community of JVM language implementations to better organize their efforts. The implementers have realized that they can share libraries to avoid duplicating effort. As an example Jython and JRuby now share a common POSIX library. In addition to the push from Sun to better support other programming languages on the JVM, the community is getting organized and doing some pushing of their own. There is now a JVM Language Implementers list on Google, which is a great way to stay on top with what is happening in this arena. Also, there is a JVM Language Runtime environment currently in development that is aiming to bring many of the features used by other programming languages to the JVM, which would hopefully improve support for some of the languages that are dramatically different than Java. This environment is even aiming to address issues regarding how these different programming languages, all living on the JVM, can interact with each other (similar to how the .NET languages can play with each other). With all of this going on, the future is looking bright for the JVM as an overall application platform.
Insight into the Ubuntu Ditro & Community
I started out in the Multicore Processors & Microparallelism talk, but that ended up being way too low level for my liking. So, being an Ubuntu user, I hopped next door to check out this talk. The talk didn’t cover anything revolutionary, just a good overview of how the Ubuntu project is organized, and how it encourages and engages its community.
Quote of the day: “Made a sick in my mouth” (aka Vurp).
Grails: Productive Web Dev. w/Groovy, Spring, and Hibernate
This was another great talk, showcasing some of the amazing features of the Grails Platform. Grails is more than just a web framework. It is a build system, an ORM layer, and more. Written in Groovy, it allows you to write code that is dynamic, flexible, and expressive. And, it doesn’t re-invent any wheels. Grails is backed by Spring, Hibernate, and several other open source Java projects that do their distinct jobs very well.
If you have any experience with Ruby on Rails, think of Grails as the Java Rails. It supports much of the features that made Rails so popular, including:
- Dynamic loading of changes without having to restart your application
- Dynamic generation of convenience methods, like dynamic finder methods on domain model classes. For example, Person.findByAgeLessThan(15) will in fact find a Person object in your database with a age less than 15.
- Scaffolding (dynamic or generated) for CRUD operations.
- Easy configuration of routes.
- Convention over configuration.
- And much more
It has a powerful plug-in system with a wealth of community developed plug-ins. These plug-ins help keep the core small, and give you the flexibility to only install what you need.
The speaker said that Grails was the next step in the continuous simplification that has been taking place in the Java world. J2EE was too complex, so Spring and Hibernate simplified it. Grails takes that a step further by simplifying Spring and Hibernate to the point where you wouldn’t even know that they are doing the work behind the scenes.
Having worked with Rails in the past, one Grails feature did stand out as a big “nice to have”: the ability to do development work with an in memory database. With Rails, you need to create a database before you can do any development work, you need to migrate that database when you update the schema, and you need to maintain test data in that database. It gets to be a pain sometimes. With Grails, you can simply use an in memory database that is crated when the application starts up. This will get you a fresh copy of the database every time you start the application. There is even a hook in the framework that will let you add test data to the database at init, so you can start every time with a fresh set of test data. Very slick.
Grails also has some nifty view technologies. You can either embed Groovy code right in the view (JUST DON’T ADD BUSINESS LOGIC) or use tag libraries. Tags are easy to add, and easy to toss into a namespace to prevent collisions.
Riding on Java technology also gives Grails some advantages, including IDE support in all 3 of the major IDEs (including debugging support), and since deploying a Grails app is just like deploying any other Java web app, we know that the technology scales.
Given our large investment in Java at Orbitz, and the wealth of Java code we have already written, I think Grails would make a great choice for any web applications that would need to interact with our existing infrastructure.
Building Ajax Applications
This talk showcased some of the new features added to the Netbeans IDE to support the development of Ajax applications, and other rich clients.
Also demonstrated were some of the capabilities that Netbeans provides to easily add rich content to your web application. There is integration with the JMaki Ajax framework that enables you to drag and drop some DHTML and Ajax capabilities right into your project. Netbeans also supports an easy drag and drop interface to add pretty graphs to your application.
Netbeans has been making great strides over the last year. Their Ruby editor is very polished in my opinion, they have great Rails support, and I know that they are targeting other languages as well. It’s sort of ironic, but I really haven’t heard much regarding the Java support in the IDE. However, given how well they are doing everything else, it might be worth checking out.
Asynchronous Ajax for Revolutionary Web Applications
This presentation covered a new spin on hot technology. Typically, Ajax involves making requests from the web browser to the server asynchronously, to avoid locking up the web browser. However, some kind of human interaction usually triggers the request, like a button click or some other mouse event. This talk described a new model for Ajax, a push model. This talk focused on some of the newer web servers and Ajax frameworks that allow you to do “event driven” Ajax. This model provides for very speedy updates, with reduced load on the server. They are speedy because the update is sent as soon as the server processes some event. And, the load on the server is lightened because clients no longer have to constantly poll for updates. This concept is known as “Ajax Push”, “Comet”, and “Reverse Ajax”.
An example of this that was demonstrated was a slideshow application. Clients would connect to the web application, and would be shown the current slide in the slideshow. When the meeting organizer advanced the slide, updates would immediately be sent to all of the registered clients with the new slide. This sort of technology could dramatically change how the web works, from request/response model to more of a dynamic, event driven model, or more likely, a combination of both.
The speakers talked about several web containers, frameworks, and other technologies that allow this to happen. Their demo used the ICEFaces framework, and the Glassfish J2EE server.
This approach brings up many questions about resource usage on the server. After all, in order to send updates to clients, the clients must maintain a connection to the server at all times. This consumes threads and sockets. The speakers said that while a server could be configured to allow many concurrent connections, it is not a wise use of resources, and you could eventually max out your resources. As an alternative, they suggested using non-blocking IO while communicating between the client and the server. Doing so lets you service many clients with just a few threads.
This way of doing Ajax is still very new, and not very well supported by all of the different web containers out there. However, many realize its significance, and a standard is on the way.