TSS Symposium—Viva Las Vegas

Keynote, May 6, 2004

The keynote on May 6 centered on TheServerSide.com. Normally, this would be frowned upon by most developers, as the keynote had little technical content and focused on “marketing fluff.” But that can be mostly forgiven since TSS is a strong J2EE community, which most J2EE developers embrace. In short, developers care about TSS, and the keynote was good clean fun with a lot of slapstick.

To sum up the keynote address, it seems that TSS is getting out of the training business and focusing on research. According to the hosts (which included Arnold Schwarzenegger, Conan O’Brien, and Homer Simpson—look-alikes of course), TSS has sold its Java training business to DevelopMentor, a company known for its .Net training and mentoring. TSS’s research endeavors will concentrate on several topics, including performance research and developer tool productivity. TSS will focus on its credibility with regards to research—largely due to its controversial .Net-vs.-J2EE performance benchmark, which has been widely disputed.

TSS plans to address research credibility with the following steps:

• Stating a public research code of conduct
• Clearly stating the relationships of companies involved in funding the research
• Allowing all artifacts used to create and reproduce the results to be freely available for download
• Working with other organizations to test and validate the work independently
• Publicizing all research

Unlike other research companies, TSS research will focus on developers and software architects instead of CIO and CTOs.

And to underscore its complete seriousness about research, Elvis joined the hosts. Elvis apparently has changed his name to Middleware Presley. He had originally changed his name to Java Presley, but apparently received a call from Sun lawyers about the use of its trademark. This was the first joke that really hit its mark, and the crowd roared with laughter. (Arnold got a few snickers, and Homer flat out flopped).

Shortly after the Elvis stunt, the speakers transitioned into how the TSS is getting a facelift and is being revamped. The TSS has a huge repository of design patterns, best practices, and compelling articles on J2EE development —a resource for many architects and developers.

To underscore its slapstick humor, TSS presented a “who’s who” of TSS Symposium attendees ala a deck of cards. The aces were Graham Glass (Web services guru), Gavin King (the king of Hibernate), Erich Gamma (from Design Patterns,) and Jeff Jackson. Hani Suleiman (Bile Blog) and Marc Fleury (JBoss Group) were listed as the Jokers. We all received a deck of cards so we can identify and capture the 52-member who’s who while we attend the conference. Hopefully, Gavin will not hide in a spider hole.

In conclusion, the keynote was fun. It appears that the J2EE community is growing and changing. TSS research has previously affected the J2EE community and the new focus on research is welcome. Research helps put some marketecture to rest and breeds the knowledge of the industry’s true best practices, instead of the ones that vendors are pushing to support hardware sales. In the words of Homer (as he is licking his lips): “mmmmmmmmmmmmmmmm research”.

Keynote, May 7, 2004

Mike Burba from Compuware gave the keynote on the power of patterns. Turns out this keynote was really a pitch for model-driven architecture (MDA). This point withstanding, it was an interesting dissertation on MDA. Mike promised at the end of the discussion, we would change the way we felt about software development. He described what software patterns are—nothing new here so far. Then he went on to explain a study found by Sun that states software patterns aid in productivity—better apps faster.

Mike then segued into patterns being most powerful when they are generative—enter MDA. MDA is a standard. MDA is not a technology; it is a technique. Essentially you use MDA to generate starter code from your UML diagrams. It will get you 80 percent of the way to the end of most use cases without much custom code, but at times, you will have to write a lot of custom code.

Developers work with their domain model, known as the technology-neutral model. Then they use a technology transform to convert the domain model into an application model. The application model is specific to a certain technology like .Net or J2EE. The developer does an implementation transformation that generates the code model. Then the developer does any unique one-off integration, and/or creates his own custom implementation or technology transformations.

Mike mentioned that OptimalJ can be used to employ this MDA technique. It includes support for pattern automation and plug-in pattern architecture for extending the architecture, which makes it customizable and maintainable.

I’ve been generating code from UML-like diagrams before UML existed (since about 1993). It is good to see tool vendors thinking of the best ways to do this. From my own experience and the experience of clients I have worked with, similar tools can be fairly useful, but they never quite live up to their promise. I hope MDA will improve this effort over time.

I am not sure if MDA will change the way I view software development, but it is certainly a topic that has interested me for a long time. I found Mike’s talk compelling.

Keynote, May 8, 2004

At the keynote address on May 8, Onno Kluyt spoke about the Java Community Process (JCP). He discussed the difference between the JCP and other groups. For example, Unix is a source standard, while Java is a binary standard. The reason the JCP cares about standards is that it cares about conformance, which ensures portability and a level playing field. Portability and a level playing field bring value to the Java brand.

Onno explained the value proposition entails three parts: developers, applications, and volume. Developers want to develop applications for platforms that are marketable. Users only want to buy platforms that have applications. It only makes sense to create applications for platforms that have volume.

Sun created the JCP to ensure compatibility and guarantee the volume will be there for developers to develop applications. Unlike other standards bodies, the JCP provides three ways to achieve compatibility: the specification, the reference implementation (RI), and the test compatibility kit (TCK; a test suite). It seems the JCP tried to create the TCKs minus the RI without success—apparently you can’t create a test in a vacuum.

Here are some interesting facts about the JCP: The JCP is 5 years old and 243 JSRs (Java Specification Requests) have been proposed. The JCP receives about 40 to 45 JSRs each year. Only about 1/3 of JSRs ever get completed, which may be a good thing—survival of the fittest for specifications. This last year, the number of personal members surpassed the number of corporate members. Still, 45 percent of all JSRs originate from Sun. The velocity of JSR start-to-finish has improved significantly, but the JCP would like it to improve more.

Onno announced the release of JCP 2.6, which promises improved speed through the following: improved transparency and openness, publicly accessible drafts, community-wide observer lists, and community-wide JSR posts. In the past, the JSR would enter a period where only expert group members had access to the proceedings—now this is much more open.

I look forward to the new JCP 2.6 changes. I have often wanted to get a sneak peek of a specification before it was finalized.