Skip to main content

TheServerSide Symposium- Day 1 - May 6th, 2004

Posted by kito75 on May 12, 2004 at 5:48 PM PDT

This is the story of my first day at TheServerSide (TSS) Symposium, which was at the Venetian hotel in Las Vegas (where I also stayed). If you haven't heard of the Venetian, it's one of the biggest and most "luxurious" hotels in Vegas. This only my second time in Vegas (the last time was 14 years ago) but from what I can tell, the Venetian's theme (Venice) errs more on the side of luxury than cheesiness. It's certainly not the place you go to enjoy cheap food or 1 cent slot machines.

I made it down to the symposium around 9AM, when the opening keynote began. There were a lot of people milling about with conference badges, lots of laptops, a couple of bean bags and several huge flat-screen monitors with promotional material. It took me a second to realize that a large percentage of these people, as well as the bean bags and monitors, were there for the Veritas Vision conference, which overlapped with the TSS Symposium. As it turns out, Veritas now owns The Middleware Company (TMC), which runs TSS. You learn something new every day.

Once I was able to filter the surroundings and examine the TSS Symposium itself, I saw that it was definitely a conference by techies for techies. It had a no-nonsense feel – no "fluff". Just sessions, keynotes, lunch (and sometimes dinner), and employees from TheServerSide trying to get you to fill out surveys. I was very happy to hear that they had wireless access points (which were shared with Veritas). Unfortunately, I wasn't able to get them working properly with my Palm Tungsten C, which I used to take a bountiful amount of notes (having a PDA with a keyboard helps). After registration, I got a nice black binder that conveniently accommodated slide printouts that were given out for (almost) every presentation.

The keynote was run by the head TMC honchos – Salil Deshpande, Tyler Jewell, and Floyd Marinescu. The purpose was twofold – welcome everyone to the conference and let everyone know where TMC and TSS were heading. They highlighted their new business model (announced earlier), which abandons the tough training market and focuses on benchmarks, lab and community research, and TheServerSide communities. The plurality of the word "community" is no accident – we already have for Java and TheServerSide.NET for .NET; the brand will also be expanded to India and China. They also mentioned a couple of new features – content-oriented newsletters and polls. All in all, it's great to see how TMC can grow TSS when they put their mind to it. I think there are good things to come.

The keynote speakers also highlighted TMC's Who's Who in Enterprise Java list, stating that they were trying to recognize some people who hadn't received too much press in the past (in addition to those who had). The list was represented as a deck of cards. Members of the deck include some fellow Manning authors – Howard Lewis Ship (Tapestry in Action), Gavin King (Hibernate in Action), and Vincent Massol (JUnit in Action), as well as Manning's publisher (Marjan Bace), and some popular industry luminaries like Mark Fleury (of JBoss fame) as the Joker. JBoss was a big force at this conference – more on that later. As a nice perk, there was a physical deck of cards taped to the bottom of each chair – nice touch!

There were, however, a few too many bad jokes, and a somewhat strange Elvis impersonation (you know, the stationary picture with the moving lips). But, people have often told me that I don't have a sense of humor, so perhaps I was missing something...

After the keynote, I ran into Nitin Bharti, who is currently the webmaster for TSS. Even though I've talked to several members of the TSS staff, this was the first time I'd met any in person.

Next, I attended Dion Almer (TSS editor) and Ron Bodkin's (New Aspects software, Aspect-J developer) presentation on aspect-oriented programming (AOP). I'll be writing about that separately, but as someone who doesn't currently use AOP, I found it quite insightful. As it turns out, AOP, along with lightweight containers and EJB 3.0, were the main themes of the conference. I got a chance to meet Dion in person after the presentation (yet another TSS member who I've only met through e-mail).

After the AOP session, it was time to attend Mike Cannon-Brooke's SiteMesh session. I've heard about SiteMesh, but I haven't used it – I'm much more familiar with tiles. Mike is the founder of the OpenSymphony project (which hosts SiteMesh, WebWork, and other projects) and Atlassian software (makers of the JIRA bug-tracking product). He covered the topic with an Australian accent and dry wit.

SiteMesh is conceptually similar to tiles, in the sense that it's a templating system, but it's quite different and arguably more powerful. The basic idea behind SiteMesh is to apply the decorator pattern to web user interfaces, implemented as a servlet filter. The top-level construct is a decorator, which is a template (either JSP or Velocity) that is declared in an XML configuration file. Decorators can be applied to specific subsets of your site (or the whole thing). This allows a back-end developer to create a form and have it decorated with the look and feel developed by a front-end developer (which can be changed, like Swing's look and feels). You can even apply decorators to non-Java applications and external resources. There are also mappers, which apply different decorators depending on the incoming request – there are default mappers, and you can write your own mappers as well. SiteMesh looks pretty good to me, and it's definitely something that I'll consider in future projects.

The first two lunches of the conference had speakers. Thursday's lunch was sponsored by Candle, and their speaker discussed performance tuning in WebSphere Application Server. The session had a lot of general performance tips, with specific examples of implementing with WAS. There wasn't a lot of new information for anyone who has experience dealing with production-level performance issues, so I skipped out to a café at the Venetian.

After a tasty ahi tuna sandwich, I hurried over to the Nutch talk from Doug Cutting, of Lucene fame. It was a small room, and Doug has a down-to-earth, pleasant, and humble demeanor. Nutch is an open-source search engine that uses Lucene. It's been around about 1 ½ years, and is currently funded by Yahoo (as a side-effect of their buyout of Overture). Doug's goal with Nutch is to make a production-quality search engine that can take on the likes of Google; he's concerned about the fact that search, which is the ultimate internet tool, is currently a closed technology. Nutch, by contrast, is completely open and usable by everybody.

Nutch was built to scale the entire web – it can handle up to 100 million pages per box, and its developers are working on something like the Google file system to handle all this data (Nutch currently uses a proprietary database optimized for web search). The engine can also perform a Google-type link analysis. This presentation was focused on using Nutch for Intranet search, which is currently one of Doug's focus in order to gain more appeal.

You can easily control the URLs you want to index with regular expressions, and the web-front end uses XSLT for the look and feel (it also uses JSP). Currently, you can't index PDF or Word documents, but support for these types is fairly easy to add. There's currently no official release, but it is stable. All in all, I'm happy to see that the product has gotten this far. It's not quite a competitor to Google, but it is stable, and there are a couple of sites that are using it as a public Google-like search engine. Currently, there's no official release, although so many people asked about a "release" that I think Doug may be considering it, if only to get more people to use it.

Next, I was off to the Tapestry session by Howard Lewis Ship, the project's creator and lead developer. Tapestry is an Apache open-source web application framework. It's quite different than frameworks like Struts or WebWork, because it abstracts web development into the composition of components, methods, and events. If this sounds like JavaServer Faces (JSF), you're on the right track – the two have quite a few conceptual similarities. As a matter of fact, I think of JSF as much more like Tapestry (which has been around for a few years) than Struts or WebWork. (I call frameworks like Tapestry and JSF user-interface frameworks, and the others foundation-frameworks.)

The talk was in a smaller room, but had a good turnout. Tapestry uses ordinary HTML templates (no JSP, Velocity, or any thing else) to define its pages. Instead of using specific tags (like JSF), you augment normal HTML tags with attributes that Tapestry understands. This underscores Howard's goal of allowing you to preview templates inside of ordinary HTML browsers and tools. (Personally, I'm pretty convinced that this isn't really a necessity, especially since most frameworks use custom tags anyway.) The basic premise is that you declare components (such as Form, DatePicker, and TextField) in your templates. You can then associate these components with server-side event handlers or model objects using the Object Graph Navigation Language (OGNL). OGNL (a separate open source project) is similar to the JSF EL, but also allows you to access methods and public static variables (which is good or bad, depending on your disposition). Like JSF, the goal is to keep you from worrying about requests and responses and focus on components, events, and model objects instead.

The session was on component development, which is one aspect of Tapestry I've been quite curious about. What's nice is that you define the component using Tapestry templates (just like you define pages). In JSF, this must be done in Java code, although using templates will probably be added in a future release. Once you've defined the template, you declare the component in an XML configuration file. You can either let Tapestry generate the component class for you, or just let it augment your class' bytecode with getters and setters for properties defined in the configuration file.

Tapestry has the basics, like validation, but it also has very good error handling and nice JavaScript integration. It also has this notion of a configurable "visit" object that is created on a per-session basis. All in all, I was happy with what I saw, and (as I've said in the past), Tapestry looks like a good, mature product. As time moves on, I'd love to see Tapestry support JSF components, and I think the two will grow more similar over time. When I spoke to Howard afterwards, he did say that he'll constantly raise the bar. It'll be interesting to see how things progress over time. We did agree to swap a copy of his book Tapestry in Action with a copy of my book, JavaServer Faces in Action.

After the Tapestry session, I headed over to a panel on AOP. I'll write about this in-depth later, but I will say that it was an interesting debate, and a lot of people are still skeptical. After the AOP panel, I headed over to the opening night party. It was held on the Venetian's pool deck, which is a pretty cool place. From the deck, you can see Venetian itself, which is a pretty attractive building to look back at.

The party itself wasn't half bad - it was quite large, mainly due to the integration of Vertias' conference. This increased the overall energy level, but made it hard to find other TSS symposium attendees. They had a little game area that was limited to a few physically-oriented video games and pinball machines. The food was pretty tasty too – I enjoyed some stuffed sea bass.

Music from the early eighties - Prince, Madonna, Michael Jackson and others - seemed to have people pretty excited. Perhaps they thought that playing music from the eighties would help prepare people for the time-shift required to enjoy KC and the Sunshine Band, which came out later in the evening. I'm not a KC fan, so when the band started playing, I knew it was time to join my wife and enjoy the Vegas nightlife.

Related Topics >>