Remember, when Windows 3.x was the prominent desktop, Microsoft announced the advent of a fundamentally new operating system that would, as they termed it, ‘changed the rules of the game’? This was Windows 95. and it did change a lot of rules—for instance, the move from 16-bit to 32-bit, a completely new interface, a newer file system (FAT32 with OSR2) and other enhancements. The next major change after 95 was in Windows NT, which used a layered architecture instead of monolithic.
With the next version of Windows—Longhorn—Microsoft is again hoping to rewrite the rules. Longhorn redoes the architecture of Windows, keeping all the good things that MS has learnt from their experiences with Win9x/ME/NT/2K/XP/2K3. this means that stuff like NTFS remains, but is enhanced greatly with other technologies or that managed code gives a better experience for both developer and end user. We will look at many such enhancements in this article.
Longhorn is the codename for the next version of the Windows OS. Expected in 2005 or 2006, the first release would be a client version – an upgrade to WinXP. There would be a server version as well sometime later.
There are quite a few new terms and technologies that are a part of the Longhorn architecture. To understand them in a larger perspective, take a look at the architecture block diagram.
There are 5 major ‘components’ on the system here. We’ll look at each one of them in detail later.
Base OS Fundamentals
This is the core of the operating system upon which a lot of enhancements are built. However, the core itself does have a large number of features. Some of them are:
Managed Provider: The entire development platform for Longhorn would be in managed code. That is, the developers would write .NET (whichever version) code for creating applications for Longhorn. This also means that since applications would be managed code, it would be more difficult to have inadvertent buffer overflows and other issues. It would also be more difficult, if not impossible to write viruses for this platform. Unlike Windows Server 2003, which had .NET pre-installed, in Longhorn, this would be actually built-in to the OS core itself.
New Graphics Subsystem: A completely rewritten graphical subsystem provides Longhorn with highly advanced capabilities that can be used by any application written for it. It is completely vector graphics based. This means that applications can easily create effects such as scaling graphics, rotating controls by any angle etc. without any pixilation! Also the new version of DirectX will give a much richer experience in games.
Better Services: Longhorn will offer better low-level services, such as Virtual Shadow Copy Services, better low-level security, transaction coordinators etc.
This is the display layer of the operating system. This is not the graphical interface, instead it is the presentation model for the entire system. All the vector-based compositing, whether for Windows or Web applications, multimedia, or animation is handled by Avalon, and services such as audio and input too.
Avalon exists as part of the higher level presentation layer and services, which are of the base system. At the higher level, Avalon defines the way applications render their look on the screen – whether it is a control on a Windows application, a movie being player of a Web page being displayed. At the lower level, it interacts with the GDI/GDI+, input manager, DirectX, sound, and input control interfaces. The best part of Avalon is that all these can be easily accessed by a programmer using managed code, or with the new programming model XAML (eXtensible Application Markup Language).
XAML is a markup language for writing Windows applications. You can write XML like code that can create complete applications. XAML lets you work with Windows controls, page layouts, formatting, vector graphics, and even animating them without code. Of course, you can attach code to perform more functions, but you can separate XAML and code just as in ASP.NET code.
NTFS, the de facto standard for the file systems based on WinNT still has some drawbacks. Major one being that there is no way of associating data with file. For instance, you cannot easily associate certain sets of files/folders with your contacts/IM buddies. Also, each application type has it’s own data storage format and schema, usually unreadable by others.
WinFS – the new storage system of Longhorn alleviates these issues. It works as a layer over NTFS and allows information (not files) to be categorized, related, shared and viewed in different ways. Using the SQL Server ‘Yukon’ engine provides a relational database model for files and their attributes.
You can now relate objects in the file system rather then dump files into folders. Consider the following example. In WinFS, you can now have a ‘view’ that shows you all documents in you ‘My Documents’ object that has any relation with a particular person in you Contacts list. For instance, you can have a ‘view’ that sorts objects by person. So selecting a person in you contacts/IM list will show all files, such as documents, photos, e-mail, etc that are associated with him. This ‘view’ is part of Windows Explorer and can be customized extensively.
This is not restricted to Windows built-in apps. Since the backend is a SQL server engine, you can easily write applications that use this feature and provide specialized services.
Indigo is meant to be a highly advanced messaging platform for Longhorn. This is one of the esoteric parts of the OS. It provides the framework that lets you perform transaction based messaging over networks, which are both secure and reliable. Also it works over heterogeneous networks – much like Web services today – but is way more advanced. It incorporated the best of current technologies such as Remoting, Web Services, Enterprise Services and others.
This is the glue that wraps all the above technologies to provide a unified programming framework for Longhorn. As veteran programmers would recall, the evolution of programming on the MS platform was MSDOS > Win16 > Win32 > .NET. WinFX is the next step in this and is a completely managed framework Of course, backward compatibility allows current Win32 and .NET applications to run on Longhorn as well.
As you can see, Longhorn is built upon a very well structured architecture that provides a lot of enhancements and functionalities. Developers will find it easier to program on it than in older version of Windows. Though, Longhorn is still in very nascent stages and a lot of plumbing still needs to be done. However, the architecture is in place and obviously is something to look forward to in the coming years.