OASIS Mailing List ArchivesView the OASIS mailing list archive below
or browse/search using MarkMail.


Help: OASIS Mailing Lists Help | MarkMail Help



   Why I Like Longhorn and XAML

[ Lists Home | Date Index | Thread Index ]

It came time to troll the Longhorn roadmap.  Here are things 
that I like about it.  I know that pages and pages and pages 
of blogs and email will be dedicated to the negatives, but here 
are positives that stand out to me from a cursory inspection.

1. Customization:  some customers have standards that require us to heavily
customize the 
look and feel of applications.  For MID, we needed a language that easily
enabled us to 
control the flow, say navigation, of content and interaction.  It was an
IETM language 
and for those not familiar with it, that means integration of procedural
testing and 
debugging of a tactical asset (say weapon system).  So we needed a very
application interface and we had to deal with the potentials of non-linear
given multiple test assets operating simultaneously (non-linerarity is a
result of 
more than one system contending for a resource at the same time).  But a
very nice 
feature is that I can choose between the browser or a standalone app just by

resetting an attribute and recompiling.  It will be fun to work out which is
when and where.  I think web browsers are a technical cul de sac, but
preserve options.

2. Cheap:  That customization has historically required Windows programmers.
Who can afford 

3. Partition tasks: Separation of code and the GUI enables us to let
graphics and UI artists design 
look and feel and use the objects the programmers develop.  We can separate
documents from 
applications.  Collaborative (say with customers en masse or in pairs )
rapid prototyping 
becomes a reality again.

4. Better monitors:  Vector graphics scale.  Bitmaps don't.  When your flat
panel TV is also 
your application monitor, you need vectors. The current WinUI must die.

5. Extensible:  just try to add your own tags to HTML.  See item 1.  If an
element is 
the surface of a class, it is a lot easier to learn and apply.  Suddenly,
XML really 
makes sense to an object-oriented programmer.  One finally has a reason to
a namespace because it tells one what implementation to use as it should.
We get a 
realized version of inheritable architectures and that will make some
Hytimers really 
happy or really increase their frustration because abstract classes don't
map to tags 
and the old Oster dot syntax is back for compound properties. 

6.  Lifecycle resistant. The old known problem of creating complex
interfaces that 
die every time the underlying rendering objects evolve or devolve.  This is
to item 2.

7. State:  having an application object to maintain state among pages and
share code 
without requiring a server to talk to (a sensible session object).  Starting
and shutting down an application is easier and more coherent.  I can say
which page starts the food chain.  See item 10.

8. Compiled over interpreted code.  We did the interpreted style in the US
Navy MID. 
It is a non-starter.  Just too frikkin' slow.  With Longhorn, if I want to
do it 
all in procedural code, I can.  Policy choice.

9.  Improved debug environment.  Thank God!

10.  Horses for Courses:  it knows the difference between a document and an
It knows if an application needs navigation or doesn't and won't insist on
it when it 
doesn't.  XML isn't SGML On The Web.  It's just easier SGML.  Navigation
isn't reliant 
on URIs. I can navigate to an object, rather than a URI.  This should excite
the IETM 
vets who worked with test procedure logic and the lost-in-hyperspace
problem.  You can 
build a smart hub and that is a very neat thing to have (think problems of
systems that create multiple possible state universes - adaptive topology.
processing is now a slam dunk).  Journaling that restores page state is

11. Neat and very familiar animation operations.  Let the games begin.  Data
to ANY UI element.  Very cool

And on and on.  I've run out of time to read the roadmap, but this is very
stuff.  Yes, the standardsGurus are going to be very unhappy and so they
be.  The standardGurus were unhappy with HTML and the emergence of the W3C.
are going to be unhappy if those horses are tired or retired.  I don't think
will happen, but being nervous about changes in our cages is how we know we
developers.  This should be fun, and for many business reasons, I can
advantages, but it is still three years in the future and that is a long
in any business these days.

Still, I'm awfully glad to see Microsoft stick their necks out this far.
and moxie are thrilling even if risky.  Too many vested companies won't take

risks and MS seems to thrive on them.



News | XML in Industry | Calendar | XML Registry
Marketplace | Resources | MyXML.org | Sponsors | Privacy Statement

Copyright 2001 XML.org. This site is hosted by OASIS