The PDC
Miguel de Icaza (miguel@ximian.com)

This is the long promised write-up of the PDC trip. It has
taken quite some time to digest what was unveiled there.

At the PDC we saw the latest ways in which Microsoft has
pushed the operating system beyond its roots into an advanced
operating system; far more than the universe of
read(), write() and poll() that Linux
developers usually think of as being "the OS."

The PDC

Brady, Gonzalo, Lluis and myself went to the PDC, to check
the latest product announcements related to the .NET
Framework. We were in for a surprise. As I left the Boston
airport, I confidently told Nat `Everything is under control,
there will be some generics, some of this and some of that,
will report back'.

I religiously sleep until noon, so waking up at 7am to
attend the keynote conference was against possibly my most
sacred principle. We had accumulated plenty of miles to be
there and we were three hours behind Boston time, so I
capitulated and was happily having breakfast at the conference
center at 8am. By 8:10 I had already purchased a stack of
books on ASP.NET 2.0, System.Xml 2.0, the new C# spec and the
annotated CLI book. Me and the janitor were the only
customers going through the books. For a second, the thought
that the conference was empty crossed my mind, but the sales
dude rapidly informed me that I had only 20 seconds to make it
to the opening keynote. I ran.

The keynote

You probably have read about the keynote material
everywhere by now. There were a few things announced:

Longhorn: their new OS.

Avalon: A new GUI toolkit for .NET.

Indigo: A new RPC framework.

WinFS: A storage facility with metadata.

Whidbey: The new Visual Studio, with .NET 1.2
(generics and others).

WinFX: The collection of all the existing and new
APIs for Longhorn.

There was a lot of wow-factor from the various demos as
they were building them. They have this new file format
called `Xaml' that is used to specify GUI layouts with XML.
It was interesting that the demos were done with Emacs and
VI. On one hand, they showed that there was no trick (or that
these technologies were not `simplexity-based'), but on the
other hand, I realized: they do not have a GUI builder for
Avalon yet.

Xaml was particularly interesting, for Gnome people this is
not news, but it is worth describing: the XML format binds the
element names to .NET classes, and each one of the attributes
maps to a property, so something roughly like:

So as you can see, pretty straightforward. Of course, the
wow-factor comes when one of the attributes can be a
video, and you can apply arbitrary Postscript-like
transformations to the whole thing. Very much like Display
Postscript-based systems, the MacOS or the venerable NeWS
system (the difference being that Microsoft will drive this
into every desktop, while the other systems never made it into
the mass market).

One of the best moments of the keynote was the demostration
by the guy from Amazon. They showed a beautiful GUI client,
that was apparently fully written using Avalon in a month of
work. I allocated a full 30 minute slot to a quest to
reimplement it at home, and I can say with authority that 30
minutes are not enough.

During the next few days of the PDC, I attended the core
CLR/.NET talks and the GUI ones; Gonzalo took on the ASP.NET
ones and Lluis attended the Indigo talks. We met with Brady
from the iFolder team at Novell, and he attended the WinFS
talks.

The BOF

My friend Benjamin
knew that the Mono BOF had not been approved by the INETA
folks, so he invited me to talk a bit about Mono on his own
BOF on Sunday, the title was `Microsoft and Academia' (this is
when we patched the main program to mention Mono). I did a
small 5-minute presentation on Mono, and got to meet a few
folks after the presentation.

On Monday, it was clear that we needed to put together
another meeting. People on the hallways were asking when we
would have the Mono meeting. In particular Sami Jaber who was
covering the event for DotNetGuru in France
volunteered to announce a new venue, and guaranteed `At least
the French contingent will show up'. So we pulled out our
maps, and found a perfect spot for the event: the Foyer that
connected two hallways in the LA Conventions Center. We
announced it on the relevant sites, and relevant blogs, and
went on with life. Picking a time for a BOF was hard: there
were pleny of other activities every day, so we basically
picked the dinner time.

The day of the event, we went to pick up the Ximian/Mono
T-Shirts to the hotel, we had plenty of time: 30 minutes to
the BOF, and the hotel was only a few blocks away. Of course,
we did not plan for one of those mythical traffic jams to play
a role, and we managed to walk back from the hotel carrying
boxes of t-shirts and being embarassingly late by 30-minutes.

Sami was there, and we started to gather a small group of
people, but once the audience identified the t-shirts, we got
together a pretty large group. The group took over all the
available seats in the foyer, probably sixty to eighty people,
hard to estimate.

I did a tiny introduction to Mono, really small, and then
the next 90 minutes we spent them doing questions and answers.
I got to meet various Mono contributors and regulars from the
list: Dave Bettin, Kral Fretch, Urs Muff and plenty of actual
users that do not hang around on the list. Since the
audience was very .NET-savvy, that made my job a lot simpler,
and the questions were fantastic. I like this format more
than the regular formal Mono presentation, but I realize that
this group of people was unique.

The introduction was basically the first ideas on what Mono
1.0 should be. The introduction, plus some of the insight
from further discussion became the Mono
Roadmap.

We now need to work hard on that roadmap and deliver on
it. It is going to be hard.

Layout

Both Windows.Forms and XAML do layout of their widgets with
some engine. The main mistake of Windows.Forms was not
copying the constraint-based system that Gtk uses, and the Gtk
containers that Gtk uses.

In .NET 1.2 they have an attempt to fix this by introducing
various new widget containers: grids (tables), flows (not
available on Gtk, but never needed it) and a few others. The
main problem is that you have to "attach" the containers to
its parent before you can do anything with them. A step in
the right direction, but too cumbersome to use.

Hopefully, Avalon will promote a different model, a more
sane one.

Xaml and Avalon

During the event everything was demoed by using this new
markup language. Of course, everything produced with it looks
terrible. And the reason is simple, XML might be a nice
replacement for a few lines of code, but doing GUI layout in
code is always a boring, error-prone, and most of the time the
results are of low quality.

Xaml was pitched as a way of splitting the work between a
designer and a programmer, which has an element of truth to
it, but in reality they need a good GUI designer for producing
interfaces (very much like Glade is to Libglade in Gnome).

Xaml is just a markup language that wires CLI classes
together, so although it was demoed as a GUI composition tool,
it could be used to wire together other components as well.
My guess is as good as everyone else: it was probably intended
to be a decent serialization format. A definite improvement
for those folks building round-tripping IDEs, since now they
only have to parse one language, and a fairly easy one to
parse as well.

Now, the Avalon components that can be wired up have been
built on its entirety on a new rendering framework, one that
seems fairly powerful: a PDF like 2D imaging system, with
video playback integrated.

This leads me to my first prediction: the first generation
of Avalon applications will:

Have a video animations sprinkled in creative
places. In a dialog caption for the sober amongst us,
and in a check-box button or a scrollbar for the
creative minds that are waiting for the technology to
be unleashed!

Will use some of the basic layout engines, so
everything will likely be stacked up in columns or
rows. It will look very much like the early Gnome.

Like early Gnome, it will be a pain to get even
the most modest interface to a reasonable state.

Will be rotated a gratuitous number of degrees.
Advanced math students will probably use a more
elaborate affine transform.

This brings me to the next point: the Microsoft folks,
realizing that Avalon turn the rest of the century on the
return of the <blink> tag on steroids, they have
produced a number of interesting documents and on their public
UI talks, they not only made fun of themselves, but they also
have visibly taken the Joel-on-Software usability pill, and
they are talking about the same thing we have been talking
about in Gnome: usability, simplification, consistency.

Building rich desktop applications with Xaml is very easy:
things can begin as "prettier" web pages. You do not have to
be a programmer to use Xaml, and if you are, you can add extra
functionality, just like Javascript does for the Web.

This of course poses a threat for the open source desktop,
more on this on the upcoming sections.

New XML File Formats

Jon Udell in his blog points
out that there are various new XML formats coming out of
Microsoft that have some ammount of overlap with exising
technologies: Adaptive Flow Format instead of CSS; Windows
Vector Graphics instead of SVG; WinFS schema definition
language vs Xml Schema.

At least for the first two, I can understand why the
engineers rolled their own. It might not even be a case of
not-invented here, it was just that given their model, it was
just simpler to follow this path.

WVG/SVG is the obvious case where it might be convenient to
bend the rules of Xaml: interop in this area is more important
than the minimal benefit of integrating with the CLR. This is just
just like coping with JPEG or GIF files: it is just not worth
changing them.

From the Mono perspective, it is still an early technology
to implement, but it is definitely an area that we are
studying and we are hoping to produce some implementation
guidelines for the most courageous developers. The core Mono
team is right now working hard in producing Mono 1.0, and we
are not planning on working on it immediately.

Avalon appears to be a large beast. I am left wondering if
this is why the Microsoft developers have been talking about
reducing the number of APIs exposed. It might be a good idea.

It might be interesting to build a smaller Avalon, one that
could run on smaller devices, and would consume less resources
would be a fun project.

Xaml as an HTML replacement.

Xaml is HTML merged with the Desktop UI

Although Xaml seems to be only a cute idea, it is simple
enough, and each one of the individual components are powerful
enough that it is very likely that Xaml could replace HTML as
a way of creating rich content on Windows platforms. It would
leave out of the equation Linux, Solaris and MacOS.

For free software users this again becomes a problem, since
we continuously face proprietary protocols and file formats as
a limitation of our platform. A limitation that we have to
address every step of the way. In the case of Xaml, it is not
the lack of documentation or a proprietary protocol, it is
just that it is intimately tied to the .NET Frameworks.

Using Mono we will be able to bridge this gap: if people
produce XAML-based applications and content, we want to be
able to render that, and to do it right, we will have to
implement the whole stack.

Various components will make XAML an attractive authoring
environment:

The file manager can browse .xaml files like it
does HTML files today.

Rich "smart client"-like functionality.

A fairly large collection of controls and
components.

Easy, centralized and secure deployment of
applications.

Use of third party controls is trivial.

Upgrade path to use any .NET language to improve
the experience beyond the basics.

A lot of fun work lies ahead of us.

ASP.NET 2.0 and XML 2.0

The good news is that the ASP.NET team surprised everyone:
ASP.NET was already simple, and they made it simpler, and they
added much wanted features like master pages, many small
controls that factor-in common functionality on web sites. My
personal favorite: pre-compiled deployment of web sites.

The XML folks did not stay behind: there are many new
features: XQuery appeared in the framework and the new
XPathDocument.

The bad news for Mono are thatn ASP.NET has more than
doubled in size since the 1.1 release and the features in XML
are fairly large improvements. The good news is that we were
starting to get bored with the existing class libraries:
largely bug fixing was the major focus, this injects a lot of
fun into the Mono equation again.

For instance, a group is already working on an early
implementation of ObjectSpaces.

WinFS

The new storage facility to be available in Longhorn has
some interesting features that have lead to lengthy debates in
the Linux communities. WinFS will be released as part of
Longhorn, so it will become available in 2006 and only to
users that migrate to the new OS.

Brady explained to me WinFS, and his own project: iFolder
3.0. The features in WinFS will be available in Novell's own
iFolder 3.0 by mid-next year. Both the workgroup client and
the server will be open source offerings, and we plan on
adding the same kind of GUI functionality that people saw at
the PDC (the UI elements are being developed with .NET:
Windows.Forms on Windows, and Gtk# on Unix).

iFolder is in fact one of the most interesting pieces of
technology that Novell has been working on, and we hope to
bring these features to Linux and Windows users (needless to
say, before WinFS ships, and in more platforms than they will
run ;-).

Some confussion still remains in the open source world
about the inner working of the WinFS. WinFS does not replace
the existing file system: it still uses it to store the actual
bits of a file. WinFS basically is a layer that can extract
interesting information from files when stored on it: the
regular data goes into an underlying file system storage, and
juicy metadata bits are extracted and recorded at this point.
One possible use scenario of WinFS is to perform queries on
the juicy information.

Jeroen and IKVM

Hacker extraordinaire Jeroen, the author of IKVM was also
at the conference, and we got to hang around with him.

The Three Pillars

At this point you might have realized that the new three
pillars of the new OS are: