O’Reilly’s Senior Java Editor, Mike Loukides, gives us his take on JavaOne, including keynotes, sessions as well as what’s hot and what’s not. Enjoy.
The keynotes were poor, particularly the first (Monday) one. Sun did a really poor job of finding interesting people with interesting things to show or demonstrate. It’s not that there weren’t exciting things to demonstrate—in a quick tour of the show floor, you’d see many demos much more interesting than almost anything that made it on stage. On the first day of the conference, Sun brought Sony up on stage. This could have been the big news of the conference: the PlayStation 2 will run Java. That could be an incredible platform for multiplayer networked games—exactly what we’ve all been waiting for. Unfortunately, all they could demo was a chat application. It was really sad—my only guess is that they finalized the deal too late to develop any real software. Yes, I understand that porting Java 3D to the PS2 is probably difficult, but still: this was a real letdown. Still, if they get 3D running on the PS2, it could easily win next year’s prize for “best Java toy.” And Philippe Kahn demonstrated some sort of a digital camera that could actually take a picture and send it across a network. Get real. Maybe I’m jaded, but I don’t care that he was sending it across a phone network, without downloading it to a PC first.
Speaking of “best toy”, the best toy I saw didn’t make it onto the stage. Jonathan Knudsen (author of several O’Reilly books, including Lego Mindstorm Robots) had a Lego robot running Java that was remote-controlled by a cell phone running Java. That’s the sort of thing Sun needed to put on stage. (It was on display in the Flashline booth.)
It’s not fair to say that all the keynote demos were a bore, but you needed to have a taste for what was going on. SoftSynth has some really interesting software for online jam sessions and musical composition. Java has had a low profile in the music world, and I’d like to see is used more. Another company (I’ve forgotten the name) demonstrated a debugging tool that let you recompile and replace a class in a running application, without restarting it. It didn’t have a lot of flash, but it’s definitely useful for developers.
The technical sessions were better than I expected, and show that Sun has taken seriously the complaints of two years ago (and, to a lesser extent, last year) about the lack of technical content. Having put together the program for O’Reilly’s Conference on Java, that’s no mean task; I can’t imagine going through thousands of proposals to assemble over a thousand technical sessions. Of the talks I went to, the best was a talk by Craig McLanahan about web architectures, but which was really showing how to use the Struts framework. Struts (which is a framework for building web applications with the MVC paradigm) is a great piece of software, and it’s well worth looking into.
Of course, the real point of the conference is to figure out what’s hot, and what’s not. Therefore, here’s a quick summary:
Wireless devices are really here, at last. I couldn’t figure out why Motorola was being so quiet, since they’re actually shipping a phone that runs Java (the i85), and were even selling it at a great price ($125) to attendees. (Bob Eckstein bought an i85 a few weeks ago, and highly recommends it. I haven’t taken the plunge yet.) Nokia was much more visible—they have some great products coming out Real Soon Now in Europe, and early next year in the U.S. The big problem with the i85, of course, is that you can’t yet download your Java applications to it. The software for downloading applications will be available later this year.
JXTA is still very new, but very much in evidence. My boss got the only applause I heard at any keynote (all right, I blew off Larry Ellison on Thursday—I figured he wouldn’t show) for saying the JXTA was Sun’s attempt to figure out “what peer-to-peer technologies nobody should own.” eMikolo had a really interesting demo that showed the potential of p2p (the only interesting demo, I might add, that made it onto the main stage): they were creating a real-time video feed by striping the feed from a number of peers. In a traditional client/server framework, all the data comes from a single server, which quickly becomes a bottleneck as you add more users. In a p2p environment, the server starts the initial feed, but as users are added, they download their content from other users—possibly many other users in parallel. Consequently, the more users you have, the better the performance is. There were a dozen or so companies demonstrating fairly significant p2p applications.
What about web services? Everyone was talking about web services. You couldn’t avoid web services. Unfortunately, a lot of the people talking about web services didn’t have much to say—the talks I went to about services tended to be generic “here’s how to create a web services architecture,” rather than “here’s how you do this.” But it’s likely that I went to the wrong talks. (I walked into the tail end of one talk that had some code on the screen—but I had clearly missed all the action.) I did like a talk introducing a common API for working with different kinds of directories for web services (JAXR); the API was sophisticated enough to let you get at the more powerful of some registry serices, and didn’t sacrifice advanced features to a “least common denominator” approach. Bottom line: Web services aren’t “cooked” yet; they’re in the process of being cooked. It’s a great time to learn about them (in particularly, the whole ebXML/SOAP/UDDI/WSDL constellation), but you still have to look a bit to find first-rate content.
On Monday, the keynote speaker made the surprising claim that Java is the leading language for application development on Linux. I found that a little hard to believe (though I’d like to believe it), but I asked a number of people, and the answer was “sure—it’s all enterprise applications, servlet-based web applications, etc.” Frankly, I think Java solves lots of problems for the Linux community, and I’d like to see it much more widely adopted. There was a good technical talk Friday morning about the future Java on Linux. The most serious problems, concerning I/O and threads, are being addressed by the new Java release (JDK 1.4, aka “merlin,” and now in beta) and improvements to Linux’s thread facilities in the Linux 2.4 kernels. That’s important, since Java seems to be the language of choice for many consumer products that run Linux internally (for example, the Nokia set-top box, or the PlayStation 2).
A number of talks discussed new features in JDK 1.4, now in beta and expected out towards the end of the year. Of these features, the most important is probably the new I/O facility. It adds a number of features that have been sorely lacking: memory mapped files, asynchronous I/O, and regular expressions. (The latter doesn’t really belong in the java.nio package, but that’s where they put it). I’ve never understood why Java didn’t have regular expressions from the beginning. The mapped file and asynch I/O extensions will make possible to build truly high-performance Java applications. One demo showed a flight simulation on JDK 1.3 and 1.4. On 1.3, it was slow and jerky; on 1.4, because of the new I/O features, which can interact directly with a graphics card, the simulation ran smoothly and much faster. Other new features are the addition of assertions and generics to the Java language; a number of improvments in Java 2D, including a new print service API; and a logging API. Swing has some new components, and the focus and drag-and-drop facilities have been redesigned. A number of important APIs have moved from being extensions to the core. These changes aren’t as exciting to me, but they are important: it is good to know that Java will always ship with the JCE, JSSE, and JAAS (cryptography, secure sockets, and authentication), along with the complete set of XML tools (JAXP).
Vendors of various voice-related products were out in force. Nuance was there; so was Voxeo. One of their developers gave an excellent talk about building voice user interfaces, and demo’d an extremely interesting rapid development environment for voice applications. The application allowed you to develop a voice application graphically, writing the prompts and responses, and leading the viewer to through the application. After building the application, he uploaded it to Voxeo’s service, then called the application on his cell phone; we heard the prompts, and watched the log as the call proceeded. Perhaps the most impressive part was that he changed the application at the last minute, and happened to introduce a bug. It took only a couple of minutes to fix the bug, upload the application to the server, and call it again. Somone later suggested that this was scripted, but I don’t think so—the speaker wasn’t good enough to pull that off.
There was some good discussion in the halls about the Java Community Process (JCP). On the whole, the system seems to be more working than broken, particularly compared to the official standards bodies that are subject to the whims and delaying tactics of vendors. (Sadly, even the IETF is suffering from this phenomenon, and the w3c is—well, the less said, the better.) A couple of valid criticisms were made, though. Sun certainly has too much involvement. Java is now able to stand on its own two feet, and doesn’t need a benevolent dictator in charge of things. The JCP would probably work just fine if Sun were no more than any other participant. Someone mentioned that the JCP has never rejeced a JSR—told someone “no, Java doesn’t need that,” and that many of the JSRs are just companies trying to standardize their product. I can’t vouch for the internal history, but a quick scan of the 136 JSRs shows that there’s some merit to the claim that that process is attempting to standardize things that probably shouldn’t be standardized, and that are really just some vendor’s technology in sheep’s clothing. It would be easier for the JCP to be selective if it were run by a truly independent body; right now, Sun certainly can’t afford to have vendors saying “we submitted a JSR, and Sun squashed it.”
JavaTV is the surprising “stealth winner” among the APIs. When it first came out, I would have picked it “most likely to go nowhere.” But JavaTV has slowly been picking up steam in critical places: it’s part of the DVB standard, part of the MHP standard, and implemented in a number of set-top boxes. (Is that deja-vu?) Given the general level of interest in the device space, I think we’ll be hearing more about JavaTV in the next few years. The big question is: does it solve any problems people really want solved? I’m not the person to ask—I don’t watch TV much. There was an interesting demo (run, I think, by Nokia) at a session on Thursday, in which they showed how you could use a settop box running JavaTV to order some records. I’d just as soon do it online—but if your life is focused around the tube, you might think otherwise. At any rate, there’s clearly something happening here.
That’s all for now. There’s obviously a lot that I missed—there were many talks about Jini, which is certainly alive and kicking (despite premature reports of its death). Apple was out in force; I didn’t get a chance to talk to them, although I think that MacOS X is a very important operating system—both for the future of UNIX on the desktop, and for the development of Jaa applications. There are no doubt many important new ideas, APIs, products, and vendors that I’ve forgotten, or that I just missed. My apologies to all who I’ve neglected. See you next year.
– Mike Loukides, O’Reilly & Associates’ Senior Java Editor
Give us your take on JavaOne.