I'm at the Microsoft Professional Developer's Conference (PDC) in Los Angeles. 

Today Microsoft formally unveiled "Longhorn", the next version of Windows.  Scheduled for shipment in 2006, Longhorn features a multimedia-capable new display framework ("Avalon"), used to create a new Windows UI ("Aero"), a new database-like filesystem ("WinFS"), new inter-program and inter-computer communication mechanisms ("Indigo"), and a new object-oriented system API ("WinFX").  In conjunction with Longhorn Microsoft is also previewing a new version of SQLServer ("Yukon"), and a new version of Visual Studio ("Whidbey"), along with updates to .NET languages like C# and ASP, and a new declarative XML-based language used for specifying Avalon display objects and properties ("XAML", improbably pronounced "zamel", by analogy to Netscape's similar XUL, which was pronounced "zool").  There's a lot of new buzzwords and concepts, all for an OS which is still three years off.  But it is exciting!

Imagine 7,500 geeks crammed into the L.A. convention center.  Everyone has a cell phone, everyone has a laptop (free WiFi everywhere), and everyone has a PDA.  Many have devices which combine the three in various ways.  Everyone is wearing tee shirts and jeans.  The average age looks to be about 29.  The majority gender is male.  The favorite drink is Coke (Jolt is not available).  The energy level is high.

I'm always amazed at how many people skip sessions to read email.  Walking around outside a session, literally hundreds of people are sitting around using their laptops, most with Outlook in the foreground.  Uh, hello, you're at a conference.  Can't you do email tonight?  Obvious victims of The Tyranny :)

Day 1 featured a keynote by Bill Gates, given in his usual "I'm bored but I'm here so what the heck" style.  He surveyed "lessons learned" by way of introduction to new versions of Windows and new opportunities for developers.  If he wasn't the founder of Microsoft - and the world's wealthiest man - would you pay close attention?  No.  He is not dynamic when addressing big groups and never seems to have much of import to say.  Sprinkled into his talk were funny videos including a terrific backhand "interview" of John Sculley (ex-CEO of Apple), comparing Newton (circa 1992) to Windows CE (circa 2003).

One takeaway from Bill's presentation was the degree to which Microsoft is working with hardware vendors.  They are really concerned about security, and feel this is a problem best addressed with a combination of hardware and software features.  Some cynics have said this is just Microsoft cozying up to content owners with strong DRM, but I actually don't think so; anytime you have arbitrary data which can be executed as code you can have security problems, and the only way to make data non-executable is with hardware support.

During Bill's talk he (ta da!) introduced Longhorn.  Hillel Cooperman did a nice high-energy survey of Longhorn, the Avalon display features, and the Aero UI, as well as introducing WinFS and some of the capabilities of this object-oriented XML-metadata-based filesystem.  A great introduction but next time we'll keep Hillel away from the coffee.

Following Mr. Bill, Microsoft GVP Jim Allchin presented "a lap around Longhorn".  During the lap he called on several members of his team to drill down.  Key to the Longhorn architecture is that new 'stacks' are being created to implement Avalon, WinFS, and Indigo, building on the foundations in Windows XP.  So good old Win32 code will happily run on NTFS files, side-by-side with Avalon code using WinFS.

Don Box and Chris Anderson did some "real" coding on-screen using Longhorn.  They built a simple sample application showing the interplay between declarative XAML and procedural C# in an Avalon GUI.  (Quite reminiscent of HTML and JavaScript in a web page, actually.)  Don and Chris have interesting stage personas, and they did a nice job of milking the "Jim Allchin as the old-timer" angle (Jim looks to be about 20 years older than Don and Chris).  I didn't get sick of Don until the very end, which is doing good.  (Don knows more than anyone about everything, but unfortunately he hits you over the head with it.)  A nerdy side angle was the use of three old-time editors, emacs (Don), slickedit (Chris), and vi (Jim), to edit the XAML and C#.  At the end they showed the new Visual Studio editing some ASP, and the contrast was dramatic (syntax highlighting, smart prompts, interactive checking and auto-complete, etc.).  It was about as good as it gets with programmers coding on stage in front of 7,500 people, and the technology looked slick and worked.

So Avalon looks pretty cool.  It is nice to separate display "templates" from code, regardless of the setting; and XAML seems like a reasonable way to do it.  Performance is sometimes an issue with such systems and it is too early to draw any conclusions about Longhorn's.  I am skeptical about how much value is really added for users with a really glitzy GUI - it is pretty easy to go too far, witness the freak show some websites give you - but the capabilities are impressive.  And a key attribute of Avalon is that it is fundamentally vector-based, enabling simple scaling and transformations to support a wide-variety of display devices and resolutions.

WinFS seems like it is just going to be too slow to be useful.  Associating XML-based metadata with files doesn't in-and-of-itself slow file access, but running arbitrary queries and groupings against a WinFS disk is going to take forever.  (Have you done a query on your Outlook folders recently?)  Soon we'll have to invent indices for frequent searches, then transactions for integrity, and we'll end up with a full-blown database storing file metadata.  That seems like overkill.  Oh, well.

Indigo is a pleasant throwback; Microsoft is finally ditching its efforts to make object-to-object interactions work across machines, and more importantly recognizing that such interactions are inherently slower than request/response interactions.  First we had COM+, then DCOM, then .NET remoting, and each was harder and slower than the next.  (Okay, that's an exaggeration, but they are all hard to code and debug, and all  s l o w.)  It was notable that during the Indigo demo of a simple inter-program communication, the level of complexity suddenly increased.  We went from simple declarative syntax in XAML to procedural objects, including ports, connectors, protocols, messages, etc.  I got kind of lost.  Made me long for good old TCP/IP sockets.  Okay, okay, I know; this is the future.  Sorry.  (But way down below, Indigo does use sockets...)

It is notable that all these demos were done using plain-vanilla editors on text files.  The XAML and C# compilers ship on every Longhorn system, as does a new tool named MSBuild (an XML version of make).  So now your customers can edit and rebuild your applications.  Nice.  In a good way, and in a bad way.  Actually the simplicity of the development tools was reassuring and bodes well for the overall architecture.

After all the on-stage coding, Jim introduced three software developers who have been beta-testing aspects of Longhorn. 

Adobe did slick demo using XAML generated by After Effects.  Yeah, you read that right; the display template was a movie.  Then they integrated some simple procedural code which supplied data into the XAML, and poof!, animated stock quotes.

Merck showed off Indigo, using inter-computer communications to simulate doctor-patient-researcher interactions during a clinical trial.  It seemed a bit contrived - especially the "research" which found an anomaly by mapping pollen readings, really, who thought of that one - but Jim Allchin made a great patient :)

Amazon had their CTO Allan Vermeulen show off a slick rich-client shopping application built on top of Amazon's web services API.  Essentially anything displayed on the Amazon website or sold by Amazon can be displayed or sold through the API.  It looked pretty "real", and in typical Amazon fashion the usability was high.  I actually think this was the most impressive Longhorn thing I saw all day.

That wrapped up Jim's lap; overall it was a pretty meaty keynote.  It is hard to say how of this stuff will make it into the final release, but Microsoft did give every developer a preview copy of Longhorn which can run all the code they demoed.  Stay tuned as I become a XAMLer.

And in a brilliant move, Microsoft also gave everyone a copy of Virtual PC.  This way developers can play with Longhorn in a virtual machine without messing anything up.  And also, Virtual PC is known to be slow, so any perceived performance problems can be blamed on Virtual PC, not Longhorn :)

After lunch I attended three sessions which discussed Avalon, Whidbey, and Indigo in more detail.  The Avalon presentation by Michael Wallent was pretty boring and discouragingly short on detail.  (Too many powerpoint slides, show us code!)  There were some interesting questions at the end about interop between Longhorn and "legacy" Win32 applications.  It appears Microsoft is bending way over to insure backward compatibility for Win32 applications, and today's .NET applications as well.  It is possible to run Win32 and .NET applications "as is" on Longhorn, and also for Win32 objects to interact with WinFX objects.  There most likely will be a performance penalty for this compatibility, but hey, it works.

Whidbey was ably presented by Scott Guthrie, using ASP.NET and featuring the many objects Microsoft provides as web-application building blocks.  Whidbey looks reassuringly similar to Visual Studio, and appears to be an incremental upgrade rather than a rewrite.  It will be available well in advance of Longhorn, to enable people to develop Avalon, WinFS, and Indigo -based applications under WinXP.  The web development environment has been nicely simplified, eliminating all the bogus side files and directories required by FrontPage, as well as the requirement for FrontPage Server Extensions.  It all looks really nice, but for building web apps I still like LAMP.  Maybe with time and familiarity I'll feel differently.

The Indigo presentation featured Don Box at his most outrageous and pontifical.  It was entertaining for nearly an hour, but unfortunately the talk was scheduled for an hour and a half, and toward the end it became painful.  It appears Indigo is one of the least complete technologies presented so far.  As I mentioned above, the key to Indigo is the conceptual transition from objects calling other objects remotely to clients calling servers using request/response messages.  Don called it "service orientation" instead of "object orientation".  He made a good point that it is pleasant to treat program-to-program interactions the same as machine-to-machine interactions, but in the end they're really different, and Indigo recognizes this.  The underlying messaging architecture is called ASMX, a derivative of HTTP developed for SOAP.  (Hey, I'm getting pretty good at this acronym soup, huh?)  Microsoft seems quite committed to improving security in Longhorn, and since machine-to-machine security is more critical than program-to-program security within a machine, Indigo has a lot of security features.

Wrapping up the day was a well-attended BOF session (birds of a feather) for webloggers, hosted by Robert McLaws (host at the Longhorn Blogs).  Also present were bloggers Robert Scoble (of course), Marc Cantor,  Werner Vogles, Clemens Vasters (author of Das Blog), Greg Reinacker (author of NewsGator), Scott Water (author of .Text), and about 100 others I don't know (sorry)!  And oh yeah, Drew Robbins and Kevin Schuler were there (hosts of PDCbloggers).

Unfortunately the discussion at the BOF was mostly about RSS vs. Atom (boring!) and MetaWebLog API vs. Echo (more boring!)  Marc managed to get people thinking about possibilities ("there will never be more than 3 million blogs, but there will be 6 million review sites") but the discussion was disjointed.  Oh well, the energy level was high; it reminded me of being in a High School club.  The boys with their little blog toys.  Except, well, you're reading this one, aren't you?

I left for the PDC at 5AM, and got home at midnight.  Cool.