JimAll: One Lap Around Longhorn

  • Article

The Longhorn Pillars

Four pillars of Longhorn from a developer perspective:

- Avalon: new display subsystem (composition)

*Indigo*: communication and web services
  • WinFS: structured, schema-based storage
  • Fundamentals: getting the basics better (deployment, reliability, performance,
    security).

WinFX is the new API (MS-DOS -> Win16 -> Win32 -> WinFX). It is written using
the .NET Framework and enables you to write Longhorn applications using managed code.

Fundamentals

- Easy deployment for new applications with ClickOnce.

New services for migration from one machine to another. Aim is to reduce the work  
necessary to rebuild a machine or copy settings from one place to another.
  • Fast rebooting via non-volatile memory
  • Adding a lot of code to improve pre-fetching of code - called "SuperFetch".
  • Security: no-execute flag for pages in memory (requires hardware support).

Presentation

- Today there is a dichotomy between web- and Windows-based applications. Both have strengths and weaknesses (deployment, graphics, connection etc.)

Avalon provides a unified presentation model for Windows, web and media applications.  
It provides a vector-based composition engine (replacing the current 2D/3D model).  
Full HighDPI support - can describe dimensions in inches, pixels or points.
  • Most importantly, we have moved to a "declarative programming model". XAML is a markup
    language that enables you to separate code from content. With XAML, you build up the
    UI design as an XML file, with code-behind partial classes implementing the underlying
    functionality. The XAML gets compiled into a partial class too, and together they
    make up an executable.
  • XAML allows you to add flow-layout as well as absolute layout. You can dynamically
    add transform decorations too (scale, rotation, alpha blending etc.)
  • MSBuild provides an XML-based build system that enabled command-line or IDE-based
    compilation.
  • The bits that PDC attendees receive contain a development theme called "Slate"; this
    isn't the final theme. The final theme is codenamed "Aero" and was demonstrated in
    the BillG keynote: very "glassy" with lots of transparency.

Storage

- WinFS provides a schema-based structure that allows for metadata to be created and searched in an arbitrary order. No longer are you limited to a hierarchical file system structure - you can drill down according to dynamically-chosen properties. Longhorn will include some standard schemas (for example, people, calendars and documents); you can extend these schemas or build your own. 

As well as the schema, WinFS is of course a store. You can physically store object  
data in the engine and perform rich queries on that data.
  • It's important to note that WinFS understands the relationships between different
    objects (so for example, a person and their documents can be related). WinFS itself
    is stored in NTFS as streams.

Communication

- Indigo will provide a message-based communication model based on web services (it's in the new System.MessageBus namespace).

It also offers support for collaboration (including a new unified API). There will  
be a single namespace for contacts that includes presence information.
  • Ports are the means via which messages enter and leave an AppDomain. Channels are
    I/O devices that are used to get messages in and out of a port.