1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
|
* The Mono Project
** Background.
The GNOME project goal was to bring missing technologies to
Unix and make it competitive in the current market place for
desktop applications. We also realized early on that language
independence was important, and that is why GNOME APIs were
coded using a standard that allowed the APIs to be easily
wrapped for other languages. Our APIs are available to most
programming languages on Unix (Perl, Python, Scheme, C++,
Objective-C, Ada).
Later on we decided to use better methods for encapsulating
our APIs, and we started to use CORBA to define interfaces to
components. We complemented it with policy and a set of
standard GNOME interfaces for easily creating reusable,
language independent components, controls and compound
documents. This technology is known as <a
href="http://developer.ximian.com/tech/bonobo.html">Bonobo</a>.
Interfaces to Bonobo exist for C, Perl, Python, and
Java.
CORBA is good when you define coarse interfaces, and most
Bonobo interfaces are coarse. The only problem is that
Bonobo/CORBA interfaces are not good for small interfaces.
For example, an XML parsing Bonobo/CORBA component would be
inefficient compared to a C API.
** Another explanation
I recently explained our motivations to Dave Winer, and he posted
it <a
href="http://scriptingnews.userland.com/stories/storyReader$1275">here</a>
** Microsoft's .NET
The Microsoft .NET initiative is confusing because it is a
company wide effort that ranges from development tools to end
user applications. .NET is a branding formative that
has been applied to:
<ul>
* The .NET development platform, a new platform for
writing software.
* Web services.
* Microsoft Server Applications.
* New tools that use the new development platform.
* Hailstorm, the Passport centralized single-signon
system that is being integrated into Windows XP.
</ul>
Mono is an implementation of the .NET development platform.
** The Common Language Infrastructure platform.
Microsoft has created a new development platform. The
highlights of this new development platform are:
<ul>
* A runtime environment that provides garbage
collection, threading and a virtual machine
specification (The Virtual Execution System, VES)
* A comprehensive class library.
* A new language, C#. Very similar to Java, C#
allows programmers to use all the features available
on the .NET runtime.
* A language specification that compilers can
follow if they want to generate classes and code
that can interoperate with other programming
languages (The Common Language Specification: CLS)
</ul>
The Common Language Infrastructure platform is similar to the
goals we had in GNOME of giving language independence to
programmers. It is more mature, documented, larger in scope,
and has a consistent design.
Any API that is written using a CLS provider language can be
used by any language that is a CLS consumer. Compilers
generate code in a format called Common Intermediate Language
(CIL) which is an intermediate representation of a compiled
program and is easy to compile to native code or compiled
using Just-in-Time (JIT) engines. The restrictions placed by
the runtime on the CIL byte codes ensures that it is possible
to do a good job at optimizing the code in a JIT compiler.
There is not really a lot of innovation in this platform: we
have seen all of these concepts before, and we are all
familiar with how these things work.
What makes the Common Language Infrastructure development
platform interesting is that it is a good mix of technologies
that have been nicely integrated.
The .NET development platform is essentially a new foundation
for program development that gives Microsoft a room to grow
for the coming years.
** ECMA standards.
Microsoft has submitted the
specifications of C#, the runtime, the metadata and the
other various bits of the .NET development platform to the
<a href="http://www.ecma.ch">ECMA</a> for standarization.
You can get a copy of the specifications submitted to ECMA
from: <a href="http://www.dotnetexperts.com/ecma">http://www.dotnetexperts.com/ecma</a>
** Mono: an Open Source Common Language Infrastructure implementation.
Ximian has begun work on Mono, a project that aims to bring
the Common Language Infrastructure platform to free systems.
When the GNU project was launched, they picked the best
operating system that was available out there, and they
began to clone it: Unix.
The .NET development platform is a very rich, powerful, and
well designed platform that would help improve the free
software development platform. Just like the GNU project
began to clone Unix sixteen years ago, we will be cloning the
.NET development platform because it is a great platform to
build on.
** What makes up Mono?
There are various pieces that will make up Mono:
<ul>
* A C# compiler.
* The Virtual Execution System: that will have the
Just-in-Time compiler, garbage collector, loader,
threading engine.
A byte code interpreter will be provided for quickly
porting Mono to new systems and debugging the JIT
purposes, but it is not intended to be the ideal
execution environment.
* An implemenation of the .NET class library.
* Visual development tools.
* A CIL GCC frontend.
</ul>
** Why use GNOME components?
GNOME is an umbrella project that consists of infrastructural
components (GUI toolkit, XML libraries, CORBA implementation,
printing architecture, imaging system), a desktop environment,
and productivity applications.
The GNOME infrastructural components can be used to quickly
implement various pieces of the class libraries without reinventing
the wheel, and since all those components are licensed under
the terms of the GNU LGPL it is a perfect fit.
Libart will be used to implement the Drawing.2D API; Gtk+ and
the GNOME libraries will be used to implement the WinForms
API and of course Glib and libxml will be used in various
places.
|
