Kito D. Mann's Blog

Community Archives

On the tour again...

Since I'm about to hop in another plane, I thought I'd mention that I'm doing a few stops with the No Fluff Just Stuff tour this Fall.

I'm presenting a few talks about JSF (surprise!) covering the JSF Ecosystem, JBoss Seam, AJAX and JSF, and Spring and JSF integration (you can find a full list on the NFJS site).

I just finished stops in St Louis and Atlanta. Next up is Minneapolis (this weekend), and then I'll be in Reston come November. It's fun to be back on the tour -- it's been a couple of years. Lots of great speakers and smart attendees. I encourage you to check out the show when it comes to your town!

JSF Training @ Open Source Live! next week in Sacramento

Javapolis 2006

I had the pleasure of speaking at JavaPolis 2006 in Antwerp, Belgium right before the holidays. And I must say, it was an excellent conference -- definitely one of the best I've been to. My session was about different AJAX/JSF toolkits ("Look Ma, No JavaScript"), and the audience was very savvy -- always a good thing.

I must point out a couple of excellent videos that have come out: JavaPolis Marriage Proposal, and Frank Cohen's video montage (complete with drunken speakers such as myself): JavaPolis2006. You can also check out pictures on Flickr. Hopefully I'll add some of my own after I develop pictures from my disposable camera...had a slight mishap with my camcorder...

At this conference I recorded my first two podcasts -- one with Tom Hammel and Stephane Bastian from Infragistics (JSF component vendors), and one with Roger Kitian from Sun (JSF co-spec lead). Hopefully I'll get these up on JSF Central soon.

Anyway, it was a great show -- and Antwerp is a great city, too :-).

RIP, Software Development Magazine

I must admit I'm a big fan of periodicals. I'm a magazine junkie. I've gotten into arguments with my wife about the pile of magazines on the coffee table (now we have a six-foot tall magazine rack instead). I regularly read SD Times, InfoWorld, Dr. Dobb's Journal, JavaPro, JDJ (which finally got good), and others at times (such as ASP.NET Pro, Wired, Business 2.0, Entrepreneur, Black Enterprise, Keyboard, Electronic Musician, and so on).

And, of course, I've always been a fan of Software Development Magazine, which CMP recently announced it is killing. Of course, they say that they're not really killing it -- they're just merging it with Dr. Dobb's. Yes, you read correctly. They're merging it with Dr. Dobb's, another legendary computer programming magazines. I'm still a fan of Dr. Dobb's, but there's no doubt that its content has been watered down over the years. And while I love Software Development, it's a very different magazine.

To me, this is a troubling sign for the industry. Software Development Magazine started about 20 years ago, and it's always had rock-solid content for architects and managers. It saddens me to see it got the way of so many other good magazines, like Byte (now on-line only) and Java Report (which was folded into a newsletter before disappearing).

I'm not sure what type of magazine Dr. Dobb's will become. After the Internet bubble burst, it became harder and harder to find programming magazines on the shelves. Unfortunately, this is just the latest sign of that trend, which I think is largely fueled by the amount of on-line content out there. Even though I read a lot of on-line content, I have a warm place in my heard for print magazines. It's sad to see Software Development Magazine go.

Vegas, here I come

There are only a few major events in the Java universe each year. The most obvious one is JavaOne, but another major one is TheServerSide Java Symposium. This conference seems to get bigger and better each year. Even though I spoke at TSS' Java in Action conference last fall, I missed their Symposium last year. Fortunately, this year they were kind enough to extend me a speaking invitation.

This year, the conference will be at Caesar's Palace in Las Vegas from March 23rd-25th. It will be jam-packed with hard core sessions, from just about every popular name in the Java world: Gregor Hohpe, Jason Hunter, Bruce Tate, Linda DeMichiel, Rod Johnson, Gavin King, Geir Magnusson Jr., Dion Almaer, Ted Neward, Patrick Linskey, Craig McClanahan, Jeff Genender, and tons of other people. I've met quite a few of these people at previous events, so I'm looking forward to seeing everyone again.

I'll be talking about Portlet Development with JSF. Here's the abstract:

Component-oriented user interface frameworks such as JavaServer Faces (JSF) are growing in popularity, and organizations are also beginning to recognize the power of building application components with the Portlet API. What many don't realize, however, is the fact that JSF has integrated support for the Portlet API, making it a natural fit for building portlets. This session starts with a brief overview of JSF, portlets, and portals. It then explains how JSF portlet support works, and examines the process of developing portlets with JSF. Next, it walks through the development of a simple JSF application and deployment of that application as a portlet inside of Liferay Enterprise Portal, an open-source portal server.

The Symposium is always a first-class event and Las Vegas is one hell of a fun city. As usual, I'm meeting up with some old friends so that I can make the most of the evenings :-).

Emerging Technology Conference

I have the privilege of speaking at Chariot Solution's Emerging Technology Conference in Philadelphia, PA on March 16th. Chariot has pulled together an excellent group of people to discuss hot new technologies and the way the technology landscape is changing. Here's the official description:

This conference features an IT executive track covering the strategic impact of up and coming technologies and two technical tracks with advanced sessions to jump-start your development using JSF, AJAX, Spring, EJB3, Apache Geronimo, Ruby on Rails and more.

I'll be joined by industry luminaries such as Bruce Snyder, Patrick Linskey, and Thomas Risberg. I'll be talking about -- you guessed it -- JavaServer Faces. My session is called "Architecting JSF Applications". Here's the abstract:

Over the past year, a lot of time has been spent explaining what JSF is, and how different pieces of it work. However, little attention has been given to the process of architecting applications. This makes JSF architecture seem like a black art, since there are so many possible approaches to the application's architecture.

This session looks at different techniques for structuring JavaServer Faces (JSF) applications, and examines the consequences of each technique. In addition, it provides an overview of how different IDEs approach JSF development, and how those approaches may or may not work within your architectural constraints. Finally the session looks at extension points within JSF, and how they can be leveraged to provide features such as security, alternate templating technology, and access to external resources.

If you're located near Philadelphia, I suggest you check out this conference. And, did I mention that it's free?

Prolific, I am not

So, if you ever read this blog, you may have noticed that I don't blog very frequently. However, I really enjoy writing (which is a good thing since I get paid to do it). I often think about blog entries and roll them over in my head. Unfortunately, a very small percentage of my in-memory blogs ever make it to disk.

In both personal and professional life, I generally attempt to resolve an issue once I realize that there is one. Often, I find that the solution is something fairly small. I decided that the best way for me to blog more frequently was to make it easy.

What could be easier than filling out a web form, you say? Well, considering that I'm often doing web development, closing browsers, launching new browser windows, and so on, a web page really isn't the right option. Also, I don't want some huge blogging client, since bloated IDEs, text editors, XML editors, and Outlook (not to mention my IM client) are all competing for system resources (most notably RAM).

It finally occurred to me that the natural way to encourage me to blog is to have a little client that lives on my desktop. That way, I can blog whenever the urge hits me, without using up too much of my precious RAM. So, I'm trying out a lightweight client called MTClient. It may not be the answer, but at least you're reading this post :-).

NFJS - Northern Virginia Software Symposium

It was a pleasure to present at the Northern Virginia Software Symposium over the weekend. The conference was in Reston, VA -- about 15 minutes from where I spent my formative years. The DC area has a lot of fond childhood memories for me, so it was a neat experience to return there as a presenter.

I taught four classes:

Introduction to Portlets

In late 2003, the Java Community Process released the Portlet API, designed to ease the progress of writing portlets for different portal environments. Using the Portlet API, developers can build reusable application components that work with portal servers from IBM, BEA, Oracle, Vignette, Apache, and other companies and open source organizations.

Intro to JavaServer Faces

JavaServer Faces (JSF) is a standard web user interface framework, developed under the Java Community Process (JSR 127), and released in March, 2004. JSF specifies a web user interface component model, complete with server-side event handling, validation, internationalization, page navigation, and declarative mapping between user interface components and Java objects.

Struts Shale: Struts 2.0?

With the growing popularity of new Java web frameworks, such as JavaServer Faces, Tapestry, and WebWork, Struts 1.x has lost its competitive edge in the web framework landscape. Recently, Craig McClanahan, the founder of Struts, initiated Struts Shale, a proposed next-generation framework built on top of JavaServer Faces.

Migrating from Struts to JSF

As JavaServer Faces (JSF), the new standard Java web application framework, grows in popularity, development teams are beginning to evaluate different strategies for migrating from Struts to JSF.

Fellow presenters included industry lumiaries like Ted Neward, Bruce Tate, Jason Hunter, Justin Ghetland, Ben Galbraith, Ramnivas Laddad, Stuart Holloway, Dave Thomas, Brian Goetz, Brian Sletten, Erik Hatcher and several others. I met Ted, Stuart, and Jason in the past, but it was nice to meet so many other bright, opinionated people :-).

I'm hoping to do more of these symposiums in the future. It's fun to teach to such a smart, enthusastic crowd, and the interaction with fellow authors and presenters is always fun.

TheServerSide Symposium - Day 3 - May 8, 2004

The third day of the TSS symposium was short – the last session ended at 4:45pm. This was definitely a Good Thing; no matter how much of a geek you are, Saturday night in Las Vegas has quite a bit of traction. And, after three nights of little sleep and the second requisite hangover, I must admit that I was happy that the final day had arrived.

The morning started with a "Communities, Network Computing & Java Technology" keynote by Onno Kluyt of the Java Community Process. TSS members seem to be a good target for the JCP, so this talk was basically aimed at convincing us to join and become active. In front of a full room Onno discussed some of the ins and outs of the JCP process, which currently has about as many members as OMG and W3C – and more individuals than corporations. One interesting fact was tthat hey are considering using the Creative Commons license for the Groovy scripting language.

Onno wrapped up with an unexpected twist – he talked about how programs were becoming a network (witness Amazon, Google, Ebay, etc.) and then discussed how Jini can be useful, stating that Orbitz is using Jini extensively. I'm not sure what this had to do with the JCP, but this was at least the second time Jini came up during the conference. It really seems like one of those great technologies with many applications; it's just that nobody I know uses it.

After the keynote, I went down to Ted Neward's discussion on Attributes in Java (JSR 175). I've read some articles about Java metadata, but I was anxious for some details, especially since I already had a reasonable grasp of how .NET attributes work. The room was small, but full. Ted's a good speaker with a sense of humor. He started implementing attributes in Java back in 2002, and his work made it into a project called Attrib4J , which was taken over by Mark Pollack. Based on Ted's work with Attrib4J (and presumably his knowledge of .NET), we was invited to join the JSR 175 expert group.

I'll write more about this session later, but here are some main points. Annotations are just special classes that look like interfaces, and consequently have no implementation – their goal is to provide additional data about your code, and that’s it. They don't replace code generators like XDoclet; they're just something that a future version of XDoclet might use instead of JavaDoc comments. You can control the annotation's target (type, field, method, parameter, and so on), whether or not they're documented in JavaDocs, when they're available (source only like JavaDoc comments, class file, or runtime), and whether or not an annotation should be inherited. I asked Ted how Java attributes compared to .NET attributes, and he said they're equal (except for the fact that you can apply Java attributes to local variables).

I've always had a keen entrepreneurial interest, so I withheld my curiosity about Spring to attend the "Opportunities in Infrastructure Software: Venture Capital Perspective on Starting and Building Tomorrow's BEA" by Peter Fenton of Accel Partners. Accel was one of the backers in JBoss' recent round of investment, so it was no surprise that Mark Fleury, JBoss CEO, and his wife, Nathalie Mason-Fleury, their Director of Communications, were in the audience. BEA's Deputy CTO, Benjamin Renaud, was in the audience as well.

Peter's company's goal, like any other venture capital firm, is to create large companies that will eventually IPO and become major brands. Typically, they invest between $500K and 25 million, and their goal is for the startup to generate $100 million in 3-5 years. The purpose of the talk was to underscore Accel's belief that there are still opportunities to do so in the infrastructure software business (and presumably find those opportunities in the audience). They believe that the industry is in the middle of transformation (witness JBoss).

Peter gave words of advice for would-be entrepreneurs: they prefer first-time entrepreneurs (less arrogant), venture capital is not a validation of an idea (it must be validated in the marketplace first, iterating with customers), and success in software is iterative (and not based on intellectual property). They also believe that licensing models are changing in response to hefty licensing fees. As a matter of fact, they aren't backing traditional software companies much these days, preferring application service provides (who charge subscriptions) instead.

I had to ask the obligatory American-software-developer question: what are you seeing in terms of outsourcing? Peter said that the trend is growing; in 2003, 25% of new companies used it, this year, the projection is 60%, and next year it will be 75% -- mostly to India, China, and the Baltics. Use of outsourcing has increased the profits and scale of their companies.

Aftwards, there was no sponsor for lunch. This gave me a chance to talk with some more TSS folks; I spoke with Nitin Bharti once again, and I also met Neven Cvetkovic and Lloyd Benson. As it turns out, Neven did a lot of the planning for the symposium (great job!), and Lloyd handles IT. It was nice to talk to someone about load balancers, monitoring, hosting options, and other fun topics.

Next, I was off to the "Eclipse - Growing from a Tools Platform to an Application Platform" session held by John Wiegand, the Eclipse Platform Lead. The room was pretty sparse, but you could tell the audience was intimately familiar with Eclipse, unlike me (I'm a JBuilder user). From the title, you can guess this talk was about how they are separating out the non-IDE elements of Eclipse into a general purpose application framework. This is part of Eclipse 3.0, which should be out in around 6 weeks.

Eclipse was originally an IDE platform (the default use of which happens to be Java), built around plugins. After some research, they found the Open Services Gateway Initiative (OSGI), which is an open platform for devices like set-top boxes, provided a superset of the Eclipse plugin functionality – it's a framework for dynamic install/uninstall/delete of bundles (which are like plugins), with security and a service-based architecture. The runtime of Eclipse 3.0 sits on top of OSGI (but is backwards compatible). This helped them move beyond just IDE support. John showed a demo of an Eclipse application that was a simple calculator – no workbench, workspaces, or anything else.

This is a pretty major release of Eclipse -- they expect to have about 8000 fixes and enhancements in 3.0. I guess that's possible when you have 65 dedicated developers (50 inside IBM, 15 outside). Eclipse has already had a major impact on the IDE industry. I'm anxious to see how it affects Java rich client development in general, especially given the constant Sun vs. IBM and Swing vs. SWT battles. (Although I understand why SWT exists, Swing is really getting a lot better).

The final session of the day was Ted Neward's session on .NET. Originally it was supposed to be a debate between Ted (editor of TheServerSide.NET and Dion Almaer (editor of TheServerSide.com, but Dion had some administrative work to do, and they figured since this was a Java-focused audience, they would just be asking questions about .NET anyway. So, Ted took a list of questions from the audience. There were so many interesting tidbits -- .NET basics, some inside history, its goals vs. Java, and some talk about the multitude of .NET languages, as well failure of Visual Basic.NET. I'll be writing up this session later (keep your eyes on FTP Online).

So, that's how the symposium ended – with a session on .NET. Well, actually, there were some other sessions at the time as well – Inside Apache Geronimo, Agile Database Tactcis for Java Experts, and Production XQuery. This was one problem with the TSS Symposium – too many good sessions. Fortunately, MP3s and slides for most of them available for registered guests. You can expect TSS to begin posting videos when they're ready to promote next year's symposium :-).

After the final session, I headed off to meet my wife and our friends for a night out on the town, and to see Cirque du Soleil's O show at the Belagio hotel-casino. I had never seen Cirque before, but all I can say is that if you haven't been, you must go. It was absolutely amazing – a perfect ending for a week full of excellent sessions and cool people plus lots of drinks, gambling, and sleep deprivation.

TheServerSide Symposium - Day 2 - May 7th, 2004

I began the second day of TheServerSide symposium with the morning's Power of Patterns keynote by Compuware's Mike Burba. In front of a full room, Mike discussed patterns as a general concept beyond the basic GoF and J2EE patterns we often think about. He defined them as common solutions to common problems in a given context, noting that they exist at the domain, platform and application levels. He also pointed out a study by Sun that claimed developers who used patterns were 5x faster than those who didn't.

The problem is that people don't model all of these patterns, and the solution – surprise! – is model-driven-architecture (MDA). The basic idea is that you start with the domain model, which is platform independent, and then transform that into a platform-specific application model, which can then be transformed into code. The process doesn't remove all coding, but it does minimize the effort. It should also be iterative, so the models and code evolve together. MDA is more than just application code, and can be applied to all parts of the development lifecycle (unit tests, QA scripts, etc.)

Compuware's solution to MDA is a product called OptimalJ, which has transformations for data access, EJB, struts, and so on. You can also build your own custom transformations. This sounds similar to Rational XDE's MDA, which I reviewed last year, so it'd be interesting to see how different the two products are. I haven't personally used MDA in a real project, but conceptually it sounds good, and I do like drawing pictures quite a bit :-). I'm not yet convinced that it is the silver bullet of application development, though.

Next, I attended "From Hibernate to EJB 3.0" by Gavin King, the creator of Hibernate</s> and a fellow Manning author. I missed the session on EJB 3.0 the previous day, so this was an opportunity for me to learn about how Gavin was going to help fix that evil they call container-managed persistence (CMP). The room was packed, and Gavin delivered his talk in a fast-speaking, fidgety manner, often referring to himself as "annoying." I'll write about this session separately, but the main point was that EJB 3.0 is going to leverage JDK 1.5 attributes, allowing you declare a POJO as an EJB instead of requiring you to implement 20 different interfaces, and it will use a lot of Hibernate's features, deprecating CMP as we know it. Hibernate will continue to be separate product (now part of JBoss), innovating in its own right.

After the Hibernate session, I ran into Ted Neward, the well-known editor of TheServerSide.NET, and one of the few people who has successfully mastered both Java and .NET. I reviewed Ted's first book, Server-based Java Programming several years ago, but we had never met in person. We discussed the reaction of many Java people to .NET (so many of them dismiss it). Ted made a good point: a lot of people are simply scared. He's seen situations where Java developers were actually replaced with .NET developers, which is the worst fear of us all, especially when there's a dearth of hiring. Whether or not it ever makes sense to replace good developers instead of training them is a different story...

We also discussed some of the features of the two platforms, and Ted mentioned his love of delegates in .NET, which I share. Type-safe method pointers are definitely a good thing, and I think they're cleaner than interface-based listeners. Method binding expressions in the JSF EL (and presumably the equivalent in OGNL) let you reference a method directly, but they're not evaluated at compile-time, which is part of the beauty of delegates.

Ted prefers J2EE, but likes .NET's Common Language Runtime (CLR) better than the Java VM. It would, however, be pretty sad if the CLR didn't have some enhancements over the VM, since Microsoft had years to tinker with the VM's code. As a matter of fact, a lot of the original .NET code was evolved from Visual J++, which might have had something to do with the recent sizable settlement between Microsoft and Sun...

After chatting with Ted, I ran over to Doug Cutting's session on using Lucene for the web. I missed the portion where he talked in detail about Lucene, which is a shame, since I was interested in learning more about it. The latter half of the talk was about Nutch, Doug's search engine that's built on <"a href=" http://jakarta.apache.org/lucene/docs/index.html">;Lucene;. I had attended a Nutch talk the day before, so there wasn't a lot of new material – just some lower-level Lucene details that were useful to existing Lucene users.

Next, I went to lunch, which was sponsored by Macromedia. Christophe Coenraets gave a presentation about their Flex product called "Extending Java and SOA with a Rich Front End". I've been interested in Flex, a component-based user interface framework built on top of Flash, for quite some time. I was even one of their beta testers, but unfortunately I never had time to really play with it. The basic idea is that you can build a rich front end that will work with any Flash-enabled browser (estimated at 98% of all browser installations), and integrate with web services and existing Java applications.

After the session, I asked Cristophe my obligatory question about their plans for JavaServer Faces (Macromedia was a member of the JSF expert group). He said that they were looking for ways to integrate JSF with Flex via render kits. Flex is a key technology to watch – I'll be writing more about it later.

I split the next block of time between Mark Hapner's presentation on Java Business Integration (JSR 208) and Jason Carreira's WebWork presentation. I've never been deeply involved in the web services space, which is the focus of JSR 208, so Mark's talk was fairly foreign turf from my perspective.

Jason's talk, however, was right up my alley, and it was quite informative. My impression was always that WebWork is superior to Struts, and now I can see why. Like Tapestry, WebWork uses OGNL for expressions. One of the features I particularly liked was the value stack, which allows you to reference properties from any object in the stack by name, eliminating the need to worry about what object is available, and where (you only have to know the property name). Also, like Tapestry, you can define user interface components in templates (a feature that JavaServer Faces lacks). WebWork doesn't have as rich of a view of a UI component as Tapestry and JSF, though.

Although I like a lot of WebWork's features (and what I saw of XWork), it still focuses on HTTP's annoying request/response programming model. I've become convinced that a higher-level event-driven model, like the ones provided by JavaServer Faces, Tapestry, and ASP.NET Web Forms, are the way to go. So, after the show, I asked Jason if anyone had talked about integrating JSF components with WebWork, and he said that someone had volunteered to do that, but he hasn't seen any code yet. This is a point I often try to stress to people about JSF: it doesn't require JSP, and you don't have to use JSF as the primary controller. It's entirely possible to use JSF components with other frameworks. If we can get JSF component support in all of the popular web frameworks, there will be a great opportunity for UI component marketplace, which will make everybody's life easier. Struts already has JSF integration, and this is something I explain in my book.

Next, I attended Darren Broemer's "Applying Architectural Style to an IT Organization" session. This one sounded particularly interesting to me, since I'm often trying to apply "architectural style" – enforcing a set of requirements and policies that ensure the cohesiveness of the code base, and encourage reuse. In my experience, it's often like pulling teeth and herding cats at the same time. I suppose Darren had some good competition, because the room was sparsely attended. At any rate, he gave some quality advice, pointing out that having an official, management-supported role is key, and emphasizing the necessity of formalizing best practices. He also said that the key to communication was actually working with people hands-on, a point with which I strongly agree.

The highlight of the day was Mark Fleury's entrance for his "Professional Open Souce and Projects" dinner keynote. Since The Middleware Company had given him the Joker card in their Who's Who in Enterprise Java list, Mark, always the showman, entered as the Joker – from Batman, that is – with a full entourage that included catwoman and the riddler. I'm not kidding – he had full makeup, and the costume too.

The keynote itself focused on one of the conference's resounding themes: aspect-oriented programming (AOP). Mark (who is JBoss' CEO) discussed middleware as a collection of aspects and the ability to inject EJB functionality with annotations. He also made a good point about AOP – in order to use the AOP features of JBoss (which are shipping today), you don't need to use AOP per-se. AOP is just part of how you use the product.

He did, however, go on to say that just about everything – quality of service, the IoC and Observer/Observable patterns, as well as 50% of the Gang of Four patterns – can be implemented as aspects. Mark also discussed JBoss' current product line, which includes JBoss Application Server, JBoss AOP, Hibernate, JBoss Cache, Nukes on JBoss, Javassist, and Tomcat. If you're wondering why Tomcat is on that list, it's because Mark claims that the JBoss group controls 45% of Tomcat's development. Whether or not that makes Tomcat a JBoss project is a different story.

After dinner, it was time for one more session – the "Future of Enterprise Java" panel, moderated by Ted Neward. The panel members included John Crupi (Chief Java Architect at Sun), Gregor Hoph (Integration practice leader at ThoughtWorks), Linda DeMichiel (EJB 3.0 Spec Lead), Mark Hapner (Spec Lead for J2EE 1.4 and JSR 208), and Benjamin Renaud (Deputy CTO of BEA). There were a couple other people on the panel, but unfortunately there names weren't listed, and my thumbs can only type so fast :-).

I didn't do a full transcription, but here are a few main points from the panel and the audience:

• Metadata will have a huge impact on future enterprise applications
• Application servers are evolving into integration servers (BEA's recent growth in the integration server business is good evidence of this)
• Lightweight services will be everywhere
• We'll see more process modeling, orchestration, and scripting languages
• Jini has features that are suitable for enterprise use, but it probably won't have an impact anytime soon
• Innovation needs to happen around tools in order to compete with .NET; good tools don't necessarily mean lack of power or features
• No one seems to have a good answer for how Java will effectively compete with .NET on the client; Sun will try to address this with future versions of Java Studio Creator; Flex might be an option
• BEA will be open sourcing parts of WebLogic to help spur tool innovation, even though most people agree that open source isn't usually focused on developing tools (except for Eclipse)
• The EJB 3.0 expert group will look into allowing EJB 3.0 support without backwards compatibility (for frameworks like Spring), but major vendors will still provide it

Afterwards, I asked Benjamin what his plans were for JavaServer Faces support; BEA was a pretty silent member of the JSF expert group. He said that they intend to support JSF, and that they will be open sourcing parts of their implementation. It'll be interesting to see what happens when BEA starts opening up their code.

After the roundtable, I headed off to meet some friends for dinner and nurse my hangover with a few drinks.

TheServerSide Symposium- Day 1 - May 6th, 2004

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 TheServerSide.com 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.

This work is licensed under a Creative Commons License.