Microsoft’s new version of the Windows operating system, code named Longhorn, is scheduled for release in 2005/2006. I believe that this new version of Windows is Microsoft’s trump card in its, yet early, battle against Linux on the desktop and the Open Source Software (OSS) movement in general.
Editorial Notice: All opinions are those of the author and not necessarily those of osnews.com
I do not believe Microsoft would have had the motivation to purse many of the ideas presented at the Microsoft Professional Developer Conference (PDC) had it not been for the competition Linux presents. I may be wrong about this, although this seems to be a typical strategy” of Mr. Gates’. Either way, the fact remains, Microsoft is now pursuing a course to “revolutionize” computing once again.
Longhorn is innovative in a number of ways. One of its major strengths is that it is almost entirely built upon an overarching and increasingly refined architecture called the .NET framework. The .NET framework is composed of the common language runtime (CLR) and a unified set of class libraries, providing developers with a core one-stop shop for all their programming needs.
According to Microsoft, the CLR “manages much of the plumbing involved in developing software, enabling developers to focus on the core business logic code”. The .NET framework supports over 20 programming languages which can be compiled to run via the CLR. In Microsoft parlance, this is called managed code. Of course most development for .NET is done with Microsoft’s own C# and Visual Basic (VB) languages. In this regard .NET is in competition with Sun System’s Java, where the CLR is basically equivalent to a Java Virtual Machine (JVM). In fact, IBM is in direct competition with Microsoft, offering an equivalent toolset centered around a Java-centric development environment called Eclipse, of course, running on Linux. Mind you, at first, it was Microsoft who was playing catch-up with Java, and the likely reason for the birth of .NET in the first place. But they have surpassed Java at this point. Additionally, there are, in fact, a number of other initiatives along these lines. Parrot is a VM being developed primarily for Perl6, and Ruby will eventually have RITE, and so forth.
It is interesting to note that one of the earliest general use VMs is called VP, which stands for Virtual Processor. VP was first developed in the 80’s, on the Amiga platform, and is a very low-level proprietary VM that is at the heart of the Intent Real Time Operating System (iRTOS) previously known as Taos, then later Elate. iRTOS underlies the very successful Intent Multimedia framework licensed to embedded developers by the Taos Group. It is very small, sometimes referred to as a nano-kernel, and very fast. It runs on a multitude of CPU architectures so that programs compiled to VP do not require recompile to run on any of the supported architectures. It is also inherently grid-enabled. And is (or at least was) a key component of the new Amiga. It is rather amazing technology. But it is not Open.
The .NET classes are extensive and are rather well developed and documented. These classes make it “easy” to “build, deploy, and administer secure, robust, and high-performing applications”. The classes include basic functionality such as input/output,
string manipulation, security management, network communications, thread management, text management, and user interface design features. Most notably they include the ADO.NET classes for interaction with data accessed in the form of XML through the OLE DB, ODBC, Oracle, and SQL Server interfaces. XML classes enable XML manipulation, searching, and translations; and the ASP.NET classes which support Web-based applications and Web services; and obviously the Windows Forms classes for desktop-based client applications. “Together, the class libraries provide a common, consistent development interface across all languages supported by the .NET Framework.”
On Linux we have many shared libraries to call upon, but nothing as unified and standardized as .NET. Although in many ways this is a strength of Linux and OSS, it is also it’s Achilles’ heel. A very large percentage of OSS development is unorganized and redundant. We may make fun of Microsoft’s slogan, “Where do you want to go today?” but OSS developers may wish to be a little less smug and consider the fact that they spend substantial amounts of time “reinventing the wheel”. The closet comparable entity that Linux and the OSS movement has to .NET falls under the GNU project. Indeed, it is a very respectable project consisting a wide range of standards, libraries and applications, genrally based around the GUI toolkit GTK+. These range from the component model
Bonobo and low-level APIs like GTK+, to complete applications like Gnumeric and Abiword and the full-on desktop environment Gnome. Ironically though, another similiar project, KDE, is more commonly used by Linux end-users, although it is based on a quasi-proprietary GUI toolkit, Qt. Commercial standards, it seems, do have their advantages.
Some of the important innovations that Longhorn is set to provide the industry, and the Windows
user at large, a few years from now, are:
- Pervasive use of XML as a single document markup systax and its related technologies.
- WinFS, a new file system based around relational database technology and natural language like meta-queries
- New user interface technologies based on DirectX, in place of the GDI interface.
Every window in the release version will be a 32-bit, z-buffered, 3D surface
- A new presentation and UI design subsystem, codenamed “Avalon,” based around a declaretive markup
styntax, the Extensible Application Markup Language (XAML)
- A new communications architecture, codenamed “Indigo,” that is an enhanced
and integrated version of Microsoft’s .NET framework
- “Improved” security and digital rights management with it’s Next-Generation Secure Computing Base
This is only a large overviewing selection of innovations.
There are many other Microsoft research project and sub-projects going into
Longhorn and certainly there may be more by the time 2006 rolls around. I have heard a number of voices
in the OSS community consider these things “old hat” and “what’s the big deal?” material.
This may be easy to say from this side of the time line, but when Longhorn rolls out, it WILL be a big deal.
And those same naysayers will eventually have to admit that this .NET Longhorn stuff is alright.
It is “alright” simply because it improves upon a number of end-user needs: it easies development and
deployment, enriches the end-user experience, and quells corporate concerns over digital rights,
just to name a few of the major addresses.
GNU/Linux, and OSS in general, does not lack for many of these innovations.
Although most are in early alpha stages, the ground work is present. The real problem lies in the
overall lack of unification of its many diverse camps, and the general approach that has been
taken toward competing with Windows. Thus far GNU/Linux has primarily approached competition
with Windows in two ways.
The most well known of these is called WINE. And it is essentially a development
project to directly emulate the functionality of Windows’ class libraries within Linux.
This allows an end-user the best of both worlds. They can run Linux applications
side-by-side with Windows applications. There is of course a severe draw back
to this. WINE development is always a step, or two or three, behind what is coming out of Redmond.
The real incentive of WINE is therefore to provide a means for users to migrate from older
versions of Windows to Linux without having to sacrifice certain functionality, i.e. applications,
to which they have grown accustomed. Obviously this is a double-edged sword. But we must give credit
to the WINE team, they have made amazing strides. Who would have even thought it possible?
WINE can even run intensive native Windows games like the SIMs. Truly an amazing
feet of backwards engineering.
The other approach is to indirectly emulate Microsoft Windows functionality in
native Linux libraries and applications. For example both Gnome and KDE include a emulation
of the Windows taskbar and systems tray. (This is not to argue that such icon menus did
not exist prior to Windows’ –that is not the point.), or the Control Panels that KDE and
other distributions now offer. This kind of development is being done across the board.
Although there is some innovation, a great deal of development is of a “we can do what you can do”
nature. Much of this work has similar goals to WINE, but differ by their focus on interoperability.
Samba is the tour de force example of this. Samba allows Linux system to communicate with,
and even centrally serve as, Windows networking systems. Again this improves migration.
A newer third way of competing with Windows has emerged, blatant indirect emulation.
This method is solely embodied in the Mono project. Mono intends to create a compatible .NET CLR
for Linux along with compatible versions of the majority of the .NET classes with various
levels of substitution targeting the GNU tools, such as GTK+ in place of Windows’ GDI.
Mono has the more ambitious goal of actually running “99ish% parallel” to Microsoft and the
.NET framework. Rather then enable end-users to run Windows application, or interoperate
with other Windows systems, Mono allows developers to easily migrate their .NET
applications to Linux with a minimal amount fuss. Like the WINE and Samba teams, the
Mono developers have made amazing strides. I was particularly impressed, upon visiting the
Mono website, with the amount of quality work that is coming out of this project. A number
of Mono compilers have already been written and a number of fairly functional applications
already exist. It does give one pause, as a developer, to make the move to Mono. But immediately
one considers moving back to Windows and using the real .NET! And there’s the rub.
Inherent in all three of these approaches, although admittedly wonderful technologies,
is one BIG FAT PROBLEM — They all play second fiddle to Microsoft Windows.
Like the little dog jumping over the back of of his Alpha-male buddy,
repeatedly begging for his kibbles-n-bits, none of these projects bring
anything particularly new to the table. On the whole, it is but a catch-up game,
day in and day out. There may be some migration advantages to this, but on the whole
it represents the single most devastating disadvantage of GNU/Linux.
Linux offers little compelling reason for users to switch platforms,
other then Linus Torvalds’ gift to the world of a rock solid and free OS kernel.
Yet most end-users have no idea what a kernel is, or even care, and rightly so.
The end-user only cares about what the system as a whole enables
him or her to do. If GNU/Linux is, for the most part, always working to catch up with Windows,
then the everyday end-user will be very much satisfied to keep with what they know.
Moreover, GNU/Linux will never be anything more the a Windows alternate, suitable only for those elite
citizens of the in the know Geekdom.
Only Redhat, and, to a lesser degree, a few other distributors such as SUSE, have really made any
strides in beating Windows on an equal footing. They have done this by focusing squarely
on a single important aspect for a narrower but lucrative area of the IT industry:
the Total Cost of Ownership of Enterprise Services. Many look to this
as the burgeoning proof of Linux’s ultimate success. But this success has quite a bit to do with
the Apache web server, for which Microsoft has had to play catch-up themselves and still remains second to,
although reportedly they are gaining! Others point to the growing embedded market,
where Linux share has done fairly well and continues to improve. But both of these are
essentially vertical markets –areas in which the market is comparatively narrow.
In this arena alternate systems have a much greater chance of success especially when backed
by strong supporting corporations.
Just the same, the ultimate power lies with the end-user. This is so simply because the
end-user is at the one at the end of the line in the use chain. If an end-user’s
clientware only functions optimally when served by the officially compatible serviceware,
the end-user will have little desire to pursue an alternative, nor will the Enterprise wish
to serve with anything but that which most enables their paying user-base.
This phenomena already exists on the Web where a number of sites do not work properly unless
accessed with Microsoft’s Internet Explorer.
Make no mistakes about it. Bill Gates is quite possibly the shrewdest business man
who ever was. Any testament of Openness on his part is just a means to pull open sourcers
away from Linux and ultimately OSS tools in general. When the time comes Mono will be pushed into a corner.
They will have difficulty staying on good terms with Microsoft. Microsoft will create a means,
if they haven’t already conceived of it, to use Mono to their advantage.
It may be as simple as requiring a licensing fee for every copy of Mono
distributed. Or it may be just subtle persistent changes to Windows, so that Mono clients don’t always
function correctly when accessing real .NET services. Any rational person who has kept abreast
of all Microsoft’s past activity knows something along these lines will happen.
And mind you, I’m not blaming Microsoft per se. They have every right to compete in the market.
It isn’t their fault if the the OSS community isn’t putting up much of a fight.
ExtremeTech Preview of Lonoghorn, http://www.extremetech.com/article2/0,3973,1368535,00.asp NGSCB, http://www.microsoft.com/resources/ngscb/default.mspx Microsoft .NET framework, http://msdn.microsoft.com/netframework/technologyinfo/default.aspx Taos Group, http://www.tao-group.com/ Amiga Anywhere, http://www.amiga-anywhere.com/ WINE, http://www.winehq.com/ The GNU Project and FSF, http://www.gnu.org/ Gnome, http://www.gnome.org/ Mono, http://www.go-mono.com/ KDE http://www.kde.org/ Samba, http://www.samba.org/ Apache, http://www.apache.org/