One of the most encouraging aspects about the .NET Framework is the
degree of openness that Microsoft has shown during its development. From the
earliest public previews, core specifications detailing the C# language, the
classes in the FCL, and the inner workings of the CLR have been freely available.

However, this openness was taken to a new level in November 2000 when
Microsoft, along with co-sponsors Intel and HP, officially submitted the specifications
for the C# language, a subset of the FCL, and the runtime environment to ECMA for standardization.

This action began an intense standardization process. Organizations
participating in the effort included Microsoft, HP, Intel, IBM, Fujitsu, Sun,
Netscape, Plum Hall, OpenWave, and others. The work was performed under the
auspices of ECMA technical committee TC39, the same committee that had previously
standardized the JavaScript language as ECMAScript.

TC39 chartered two new task groups to perform the actual standardization
work: one to focus on the C# language, the other to focus on what became known
as the Common Language Infrastructure (CLI).

The CLI consisted of the runtime engine and the subset of the FCL being
standardized. Conceptually, Microsoft's CLR is intended to be a conforming
commercial implementation of the runtime engine specified in the CLI, and
Microsoft's FCL is intended to be a conforming commercial implementation of
the class library specified in the CLI (although obviously, it is a massive
superset of the 294 classes ultimately specified in the CLI).

After more than a year of intense effort, the task groups completed
their standardization work and presented the specifications to the ECMA General
Assembly. On December 13, 2001, the General Assembly ratified the C# and CLI
specifications as international standards, assigning them the ECMA standards
numbers of ECMA-334 (C#) and ECMA-335 (the CLI). Copies of the ECMA standards
are available at http://www.ecma.ch.

Critics have claimed that the ECMA standardization process was merely
a ploy by Microsoft to deflect Java's cross-platform advantages. However,
the qualifications and seniority of the people working on the standardization
effort, and their level of involvement during the lengthy standardization
cycle, tell a different story. Microsoft, along with its co-sponsors and
the other members of the standardization task groups, committed some of its
best and brightest minds to this effort, spending a huge amount of time and
attention on the standardization process. Given that this effort occurred
concurrently with the development and release of the .NET Framework itself,
this level of investment by Microsoft and others flies in the face of the
conspiracy theories.

Of course, for standards to have an impact, there must be implementations.
At the time of this writing (January 2001), no fully conformant reference implementations
were shipping. However, there are several efforts already under way to
provide open and shared source implementations of the C# language and the
CLI, for both commercial and noncommercial use.

Microsoft is working with Corel to provide a shared source implementation
of the CLI, as well as C# and ECMAScript compilers that target it. This project,
codenamed Rotor, is expected to ship in 2002, and will
run on both Windows and FreeBSD platforms. Although specific details of the
shared source license were not available at the time of this writing, it is
expected that this CLI implementation will be licensed for noncommercial
use by researchers, hobbyists, and academics.

However, Microsoft's implementation is not the only game in town. Other
CLI implementations include the Mono project and dotGNU.

The Mono project (http://www.go-mono.com), started by Ximian
Corporation, is aiming to provide full open source (GPL and LGPL) implementations
of not only the CLI platform and the C# compiler, but also a larger set of
classes selected from Microsoft's .NET Framework FCL. In addition to the internal
resources that Ximian has committed to the project, the Mono project has also
attracted attention from the broader open source community, and appears to
be gathering steam.

Finally, consider the open source (GPL) dotGNU project
(http://www.dotgnu.org).
While not as high-profile as Mono, dotGNU has also been making headway, and
includes some interesting and unique concepts. The core of dotGNU is Portable.NET,
which was originally developed by a lone developer (Rhys Weatherley) before
merging his project with dotGNU in August 2000. There are unique aspects to the dotGNU
project, including the fact that it was originally designed around a CIL interpreter
rather than a JIT compiler (although the team plans to add JIT compilation
at a later date), and the developers' plan to support directly
executing Java binaries.

Beyond these three, it is very likely that more implementations of the
CLI will arise over time. While it is too early to say whether the
.NET Framework (in the form of the CLI) will ever be available on as many
platforms as Java is, the degree of openness and the level of community
interest is very encouraging.