Useful gems from SIGS Conference for Java Development

The SIGS Conference for Java Development, held October 18 to 22 in San Jose, CA, made an interesting first impression on me. I arrived early to pick up my registration materials and attend a pre-conference tutorial. I expected a rather sparse attendance that first day, but I was surprised to find that as the conference progressed, the number of attendees never grew to fill the halls.

It wasn’t just an opening-day phenomenon, the conference really was much smaller than its monstrous Java brethren: JavaOne and the semiannual Software Development conference. Approximately 3,000 developers and expo attendees made their way through JavaDevCon’s exposition, with about 550 people attending the 49 technical sessions and 10 pre- and post-conference tutorials. This makes JavaDevCon an order of magnitude smaller than JavaOne or Software Development.

But is bigger always better? Not necessarily, especially when you’re paying to meet and interact with speakers and attendees. A small, well-focused technical conference can be more useful than a large one. In the case of JavaDevCon, smallness begat sveltness. Speakers and attendees were able to get to the point and discuss the real problems facing developers using Java technology. Not bad for a little conference in early autumn.

Microsoft and Sun argue server component models

Since the dawn of object-oriented time, people have been fighting about how to properly build objects and make them available for others to use.Arguing over component models must be one of the world’s oldest programmer preoccupations. As Java has gained an increasingly devout object-oriented following, developers have exhibited renewed interest in arguing the right way to build truly reusable component-based software.

In an effort to continue the discourse, Michael Vizard, an editor at InfoWorld (sister publication to JavaWorld), hosted a panel entitled Server-Side Component Models: Microsoft’s MTS vs. Sun’s EJB. (MTS stands for Microsoft Transaction Server, EJB for Enterprise JavaBeans.)

It was strange, and at times comical, to see Sun’s Java and Microsoft’s COM product managers face off in a development debate. I had to wonder if they understood the audience they were trying to sway. Developers are a savvy lot, not easily impressed by marketing hype, yet we were forced to sit through the usual round of slogans and mudslinging. Sun’s Bill Roth was particularly harsh concerning the single vendor availability of MTS, while Microsoft’s Michael Gross expressed equal concern with Sun’s control of the EJB spec. (See Resources for InfoWorld‘s detailed transcription of this panel session.)

The real gems didn’t surface until the question and answer session after the moderated comments, when developers aired their grievances in full. One developer expressed concern that MTS does not support stateful objects. Mr Gross responded that to properly scale applications up on NT servers, software should be written to use a stateless model, and further, that most applications could be written successfully using a stateless model. Mr Roth responded that it was “unconscionable” that Microsoft wouldn’t provide stateful object support in MTS, underscoring the fact that Java and EJB have objects and stateful objects as a core concept.

Scott Ambler, object-oriented guru and columnist for Software Development magazine, mentioned scalability problems with both MTS and EJB servers. He discussed problems in an MTS application with as few as 200 simultaneous users, not excessive for an enterprise application. He also pointed out memory leak problems with EJB-based solutions. Given Mr Ambler’s credentials as an object-oriented design expert, one can assume that he produces quality code. Gross, however, plainly stated that scalability problems almost always stem from poorly written code. Although there is a grain of truth in that statement, you have to wonder if some fundamental problems are lurking under the MTS and NT covers. Roth did not have much to add, except to say that Sun is focusing current engineering efforts on fixing memory leak and related bugs.

Finally, when asked whether someone could swap out MTS and replace it with something different, Gross quickly answered no, that MTS is an integral part of the operating system and system services. Roth retorted that IBM would likely make a different statement if asked to integrate a different transaction server into a customer’s solution, and that whatever server is ultimately chosen, it is in the customer’s best interest to not be “locked into a Microsoft-only solution.” Gross responded that MTS was open, and in fact that efforts were underway to make MTS and COM available on systems besides NT. When asked if that meant that a developer would be able to run MTS on an AS/400, Gross hurriedly responded “There are no announcements that I can make about that at all. I can’t make any kind of announcement about that right now.”

Leave it to developers to get marketing excited!

Course tutorials and technical sessions

The technical sessions and tutorials are the backbone of any well-produced technical conference. JavaDevCon was no exception.

According to SIGS representatives, the most popular technical sessions at the conference focused on:

• Enterprise JavaBeans
• Java tips and tricks
• Object Serialization and RMI
• Advanced interface design
• XML and Java
• CORBA and Java

Following is a short listing of the sessions I attended, with a brief overview of the content of each. I have tried to include interesting comments and tips from each. Where possible, I have included links to the presentation and related materials for each in Resources.

• Efficient Java Servlet Programming, Jason Hunter, K&A Software — Jason began with an overview of Web programming and the various approaches, then explained the advantages to Java Servlet. He also provided some tips on which servlet engines to use (hint: not the one built into Netscape servers), described the Servlet API and lifecycle, and demonstrated the utility of Java Server Pages (JSP). Jason’s materials were by far the most thorough of any tutorial I attended, even going so far as to include a student workbook with questions at the end of each section of the presentation and course notes. Here’s an inside tip: Watch for Jason’s detailed analysis of the Servlet 2.1 API, tentatively scheduled for the December issue of JavaWorld.

• Multi-Threading Techniques and Patterns in Java-Based Programming, a Java User Group Meeting with a presentation by Gerry Siedman, IAM Consulting — The room was full and the projection screen was impossible for me to see at this early-evening meeting. I would not have described it as a JUG meeting myself, but rather as an evening tutorial: there was very little JUG-like business, mainly just a talk by the speaker. In any event, the presentation was very animated. Certainly the most lively description of multithreading I have ever heard!

• Java Debugging & Profiling Techniques, Ethan Henry, KL Group — This was the single most useful tutorial I attended. Ethan gave a very practical talk. He outlined the sorts of errors that can occur in Java code (syntactic, static, and dynamic), then dove into a description of the various approaches to debugging Java code. His solutions were as basic as System.out.println() and as advanced as taking thread dumps and analyzing the state of each thread running in the virtual machine. The juiciest tips included the Magic Thread Dump Key (Ctrl+Break on Win32, Ctrl+ or kill -QUIT [pid] on Solaris and many other Unix variants), the Magic AWT Dump Key (Ctrl+Shift+F1), and Magic Netscape Console Keys (type ? in an Netscape Java console window for a list of debug options).

  Ethan also listed common performance problems that profiling tools can help developers locate, including excessive heap expansion, not using System.arraycopy(), using the + operator with String objects, using unbuffered I/O streams, excessive memory allocations, and excessive calls to slow library methods. His presentation was far from revolutionary, but the collection of useful tips applicable for any Java developer was unparalleled by any other session I attended.

• Getting Started with Swing, John Zukowski, MageLang Institute — A basic introduction to the Java Foundation Classes (JFC), focusing specifically the portion known as Java Swing. John did a very good job pointing out problems with the original AWT widgets and how Swing addresses these problems, and he presented nice examples for many of the most important Swing components. John also provided useful hints for when to use each component (for instance, JToggleButton is great to use in tool bars). For some additional information on JFC and Swing, don’t miss John’s article on Java 1.2 in this month’s issue of JavaWorld.

• Programming the Java Layout Managers, Peter Haggar, IBM Corporation — I found this talk too introductory, but it was very complete in its coverage of the layout managers built into the core Java APIs. If you are learning about or evaluating one of the standard layout managers, I would recommend browsing through Peter’s slides (see Resources).

• Techniques for Building a Multi-Threaded Server in Java, Alex Chaffee, Purple Technology — Alex provided a great overview of the threading model and threading support designed into Java — some might say hacked into Java, after reading through Alex’s materials and realizing how poorly named Thread really is (see Resources). His presentation is worth at least a quick skim by every Java developer who dabbles in multithreaded programming, which, given the nature of current browser JVMs, applies to most of us.

• Understanding Dynamic Extension in Java, Bill Venners, Artima Software — Bill has done a good job of turning the content of his former JavaWorld column, Under the Hood into a tutorial on the dynamic nature of Java. This tutorial focused on the usage of class loaders. There are some ingenious uses for class loaders outlined in Bill’s notes (see Resources), including loading files not in the CLASSPATH, decrypting enciphered class files on the fly as they are loaded, and even creating class files on the fly, if needed.

• Programming with the Java Media APIs, Bill Day, SGI — My own 90-minute tutorial served as a solid introduction to multimedia programming using the core and extension Media APIs. I was told to expect about 25 attendees (27 pre-registered), I brought 50 sets of handouts, and I was pleasantly surprised that I ran out by the end and had to give someone my own copy. But fear not if you didn’t get a copy: My presentation is available in its entirety from my Web site (see Resources below).

How does JavaDevCon stack up?

By all accounts, JavaDevCon was significantly smaller than Sun’s JavaOne or Miller Freeman’s Software Development (SD) conferences, two of the biggest competitors for developer dollars. The small size of the show was both a major strength and its greatest weakness: the small rooms and close proximity in the tutorials and sessions made for a lot of interaction between the speakers and the attendees, but at the same time, the expo floor felt rather empty and under-attended at most times I visited.

It is interesting to note that Sun’s official presence at the show was extremely limited. Sun’s expo booth was unmanned when I stopped by, and it had only a few brochures, mostly recruiting literature, out for attendees to pick up.

Another difference evident at the show: whereas JavaOne is heavily dominated by Sun and the Sun PR machine, the nature of SIGS’ publishing and conference business lead to a relatively content-rich, marketing-lean conference, just what developers want from a technical program. In this respect, the JavaDevCon was more similar to SD than to JavaOne. In contrast with SD, though, JavaDevCon takes the liberty of focusing on Java-related technologies. If you have Java-specific development issues or need Java training, this focus can provide for a more effective conference.

Conclusions

I wrote in a recent article on Siggraph ’98 that:

Java has infiltrated the fibers of net-aware programming to the extent that it has become difficult to find very many Web applications that do not use Java in some way.

The SIGS Conference for Java Development continued driving home the point that Java is here to stay, not just for Web programming, but for most new distributed and networked development projects. The conference was small, but the program offered the hands-on tutorials, case studies, and technical material developers crave. Hopefully SIGS will continue this lean and mean approach at next year’s JavaDevCon.