Jeff seems to like Cringley's statement
of "The central point was that paying too much attention to
Microsoft simply allows Microsoft to define the game. And when
Microsoft gets to define the game, they ALWAYS win."
A nice statement, but nothing more than a nice statement,
other than that, its all incorrect.
Microsoft has won in the past due to many factors, and none
of them related to `Let them define the game', a couple from a
list of many:
- They leveraged their monopoly to break into new
markets. The most discussed one is when they used
brute force and anti-competitive strategies to get
their products into new markets, but in some other
cases they got fairly good adoption of their products
with little or no effort: just bundle it with Windows:
MSN messenger, Media Player.
- Competitors were outmaneuvered or were incompetent
(See HIgh Stakes No Prisoners).
- People were sleeping at the wheel.
In 1993-1994, Linux had the promise of becoming the
best desktop system. We had real multi-tasking, real
32-bit OS. Client and Server in the same system:
Linux could be used as a server (file sharing, web
serving), we could run DOS applications with dosemu.
We had X11: could run applications remotely on a large
server, and display on small machine. Linux quickly
became a vibrant innovative community, and with
virtual-desktops in our window managers, we could do
things ten times as fast as Windows users! TeX was
of course `much better than Windows, since it focuses
on the content and the logical layout' and for those
who did not like that, there was always the "Andrew"
word processor. Tcl/Tk was as good as building apps
And then Microsoft released Windows 95.
- A few years later, everyone is talking components:
Netscape is putting IIOP on their client and server
(ahead of their time, this later became popular as
web-services on the browser); Xerox ILU; Bonobo;
KParts; the Borland sponsored event to build a small
component system that everyone agrees with; language
bindings are at their top.
The concensus at that time? Whatever Microsoft is
doing is just a thin layer on top of COM/DCOM/Windows
DNA which to most of us means `same old, same old, we
And then Microsoft comes up with .NET.
Does something like XAML matter? Not really. But it makes
it simple to create relatively cute apps, by relatively newby
users, in the same way anyone could build web pages with HTML.
Does Avalon really matter? Its a cute toolkit, with tons
of widgetry, but nothing that we cant do on a weekend, right?
Does the fact that its built on top of .NET matter? Well,
you could argue it has some productivity advantages, security
features and get into a long discussion of .NET vs Java, but
its besides the point.
Everyone is arguing about tiny bits of the equation `We
have done that with Glade before!', `Gtk/Qt are
cross-platform!', `We can get the same with good language
bindings!', `We already have the widgets!', `Cairo is all we
need', `What do users really want?' and of course `Dont let
them define the game!'.
They are all fine points of view, but what makes Longhorn
dangerous for the viability of Linux on the desktop is that
the combination of Microsoft deployment power, XAML, Avalon
and .NET is killer. It is what Java wanted to do with the
Web, but with the channel to deploy it and the lessons learned
from Java mistakes.
The combination means that Longhorn apps get the web-like
develop centrally, deploy centrally, and safely access any
content with your browser.
The sandboxed execution in .NET  means that you can
visit any web site and run local rich applications as
oppposed to web applications without fearing about your data
security: spyware, trojans and what have you.
Avalon means also that these new "Web" applications can
visually integrate with your OS, that can use native dialogs
can use the functionality in the OS (like the local contact
And building fat-clients is arguably easier than building
good looking, integrated, secure web applications (notice:
applications, not static web pages).
And finally, Longhorn will get deployed,
XAML/Avalon applications will be written, and people
will consume them. The worst bit: people will expect
their desktop to be able to access these "rich" sites. With
90% market share, it seems doable.
Will Avalon only run on Longhorn? Maybe. But do not count
on that. Microsoft built IE4 for Windows 98, and later
backported it to Windows 95, Windows 3.11 and moved it to
HP-UX and Solaris.
The reason people are genuinely concerned and are
discussing these issues is because they do not want to be
caught sleeping at the wheel again.
Will this be the end of the world for Linux and the Mac?
Not likely, many of us will continue using our regular
applications, and enjoy our nicely usable and consistent
desktops, but it will leave us out of some markets (just like
it does today).
Btw, the Mozilla folks realized this already
 Although it was easy to see why .NET supported the Code
Access Security (CAS) in .NET 1.0, there was no real use for
it. With Longhorn/Avalon/XAML it becomes obvious why it was
Planning for the future
Although some of the discussion has centered around using a
native toolkit like Gtk+/XUL to build a competitor that would
have ISV sex-appeal, this is not a good foundation as it wont
give us Web-like deployment (we need a stack that can be
secured to run untrusted applications, and we need to be able
to verify the code that is downloaded, which leaves us with
Java or .NET).
The time is short, Microsoft will ship Avalon in 2-3 years,
and they got a preview of the technology out.
I see two possible options:
- Implement Avalon/XAML and ship it with Linux (with
- Come up with our own, competitive stack.
I think someone will eventually implement Avalon (with or
without the assistance of the Mono team), its just something
that developers enjoy doing.
If we choose to go in our own direction, there are certain
strengths in open source that we should employ to get to
market quickly: requirements, design guidelines, key people
who could contribute, compatibility requirements and
We have been referring internally at Novell to the later
approach as the Salvador platform (after a long debate about
whether it should be called MiggyLon or Natalon).
We do not know if and when we would staff such an effort
but its on the radar.
The patent issue
Are there patents in Avalon? It is likely that Microsoft
will try to get some patents on it, but so far there are
little or no new inventions on Avalon:
- Canvas graphics, persistent objects (Tk Canvas,
- With AA/vector-based graphics (Gnome AA Canvas)
- With animation (Nautilus Andy-branch Canvas items)
- With Vector graphics (Gnome Print, librsvg)
- With A 2D graphics model (PDF, Libart, Cairo)
- With Web-like-Deployment security (SecureTcl, Tcl Plugin, Java)
- XAML has been done before (Glade, Qt designer),
but am not sure that XAML is the best "authoring" model yet.
The power lies in their deployment power.