Kito D. Mann's Blog

May 2004 Archives

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.