Tuesday, April 18, 2006

[itsdifferent] Open Source Dot Net - The three Musketeers

There are at least three Open Source implementation of Microsoft’s Dot Net platform – Mono, DotGNU and Rotor. Though there are a few other implementations happening at some remote corners of the World Wide Web, these projects are insignificant at least at this point of time.


In this article we will review each of these projects and figure out where all of them stand as far as quintessential developers go.


All the Open Source projects are miles behind the original Dot Net platform. Hence, this makes it unattractive for a developer working on cutting edge Dot Net platform to switch over to one of these projects for developing applications. However, each of them is developing a niche for themselves.


By far the most controversial and promising of all Open Source Dot Net projects, Mono was originally conceived by Miguel De Icaza of Ximian. Last year the company was acquired by Novell, as a part of one of the many high profile acquisitions which Novell made, as the company reinvented itself as an Open Source/Linux player.


It is a well-known secret that the Mono project has support from Microsoft. In fact Miguel de Icaza has gone on record on the fact that he draws a lot of inspiration from the way Microsoft has approached solving the various business issues.


Mono project is currently having a version number 1.1.8.


Mono is officially an Open Source implementation of Common Language Infrastructure (CLI) of the European Computer Manufactures Association, better known to most as ECMA. The Dot Net standards are actually an ECMA standard.


To the best of our belief, Mono does not have a single line of code of Microsoft .Net platform. It is a complete rewrite and is targeting every platform from Linux to Windows.


What do you get in Mono?

A Common Language Runtime (CLR) that is compatible with the ECMA standard;

A C# compiler;

A set of class libraries which includes implementations of ADO.net, ASP.net, Winforms, 
      GTk#, Gtk toolkit; and

Ancillary tools such as a disassembler, debugger, IDE, etc.


The current version is more or less compatible with Microsoft Dot Net framework 1.1. This means that any code that compiles on Microsoft Dot Net will actually run on Mono.


Work is in progress at Novell, and several developers are writing code across the globe and even in India.


Some of the implementations where work is on include:
 1. C# 2.1 implementation;
 2. AMD64 JIT port;
 3. Visual Basic compiler;
 4. Improved IO-Layer and Internationalization framework;
 5. Gtk# improvement and GUI designer;
 6. Mono Debugger;
 7. Windows.Forms support;
 8. JIT performance work;
 9. Integration of patches that were too big to make it into the 1.0 release;
10. Code Access Security Framework;
11. Continued bug fixing of major and critical bugs;
12. Support for Java and Basic;
13. New XML classes;
14. An OpenGL class called Tao Framework;
15. Cocao support Mac’s OSX; and
16. Web Services enhancements.


The final goal of Mono project according to Miguel is to extend the technology beyond the current Microsoft Dot Net framework. The plans, at least on paper, is to create a free platform that is both operating system and language independent.


Though there are many exciting new features added to the Mono platform, that adds value to the overall appeal of the platform, it still is largely unstable, especially when you try porting huge C# or VB.net applications from Windows to Linux.


But among all available cross platform options, Mono is the most attractive. Unlike others that are supported by a bunch of Open Source developers, Mono has the backing of resurgent corporate giant Novell, which in turn has funding from IBM.



DotGNU is getting ready to make a big splash though the current release is version 0.1. However, the project is said to be picking up steam and there may be more action in store in the coming days. It is of interest to many hardcore Open Source developers, since it is in accordance with the GNU project. DotGNU has several projects under its umbrella.


DotGNU Portable.NET is a project under the DotGNU meta-project. Its goal is to build a suite of free software tools to build and execute Common Language Infrastructure (CLI) applications. The initial target platform is GNU/Linux, but it has been known to work under Windows, NetBSD, FreeBSD, Solaris, and MacOS X, among others. It also runs on a variety of CPU's including x86, PPC, ARM, Sparc, s390, Alpha, ia-64, and PARISC.


DotGNU Portable.NET is focused on compatibility with the ECMA specifications for CLI and extensions as defined by the .NET Framework SDK.



DotGNU Portable.NET contains a runtime engine, C# compiler, and a host of useful development tools, all written in C. This package is generally referred to as "pnet".


The C# system library was split off from the main source distribution during the early phases of development to create the "pnetlib" package. It contains implementations of the major C# class libraries, including "mscorlib.dll", "System.dll", "System.Xml.dll", "System.Drawing.dll", "System.Windows.Forms.dll", etc.


Treecc is an aspect-oriented programming tool that was written to assist in the development of DotGNU Portable.NET's compiler, "cscc". It complements flex and bison by providing support for abstract syntax tree creation and manipulation Treecc performs most of the housekeeping within the core of the compiler, allowing the programmer to concentrate on the specifics of language implementation.


PNetMark is a benchmarking tool for Common Language Runtime (CLR) environments. It is loosely based on the techniques used by CaffeineMark to benchmark Java.


The regression test suite for the C# compiler is distributed via CVS as the module "cscctest".


Since version 0.4.4 of DotGNU Portable.NET, the cscc compiler has had support for compiling C programs. The companion libc implementation for the C compiler is called "pnetC". The code is based on glibc.


The C Sharp Compiler Collection (cscc compiler) is designed so that it can compile to either IL or JVM bytecode. Adding other output formats would be quite easy. There is still some work to be done in assembling JVM bytecode, but most of the support code is in place.


The Win form classes are almost done, with a few loose ends to be tied up. Web forms (ASP.net) is still in primitive stages.


We found the installation of the Protable.Net a little tedious compared to Mono. There are too many bugs still as there is a lot to be fixed.


If you are moving from Windows to Linux attempting Dot Net adventures, then Portable.Net may be an adventure of sorts.



From the Microsoft web site “Released on 27 March 2002, Rotor provides a free, Shared Source implementation of Microsoft’s Common Language Runtime platform, including source code for C# and Jscript compilers, as well as for the Common Language Infrastructure (CLI) platform itself. It also contains source code for a variety of useful developer tools, including a Common Intermediate Language (CIL) assembler, a disassembler, a debugger, a profiler, and an assembly linker. The Rotor code can be used, modified and re-distributed, for non-commercial experimentation, as a basis for courseware or lab projects, or as a guide for those developing their own commercial ECMA implementations. (The specifications, already ratified as international standards by the European Computer Manufacturers Association (ECMA Standards 242, 334 and 335), are undergoing ISO Fast Track processing.)”


Rotor is also there for hobbyists as well as university and commercial researchers. Academic users will be able to integrate it into courses and labs, since Rotor can be used as a foundation for other applications and tools. Additionally, since Rotor can run side-by-side with the commercial .NET Framework SDK, you can easily test the same bit of code on both.


Rotor is in a way an attempt by Microsoft to appease the Open Source community.


The current targets are Windows and FreeBSD, but ports to other platforms are possible. Rotor relies on a Platform Adaptation Layer (PAL), which is similar to Apache's Portable Runtime (APR) in that it provides an abstraction layer between the runtime and the operating system. In theory, porting Rotor should involve nothing more than porting the PAL.


Rotor is fairly stable, and there cannot be many complaints about the documentation. However, it lacks the features, and in many ways this looks like a muted application, with no definite road map to the future. Rotor is strictly for academic purposes.


Deven Goratela
देवेन गोरातेला

Note: This Group is not a Job Searching Group, so please co-operate and dont transfer any kind of job related material across this Group.AnyOne doing so can be banned from the Group
Thanx , Group Co-Ordinators


No comments: