Implement some additional logic around AddServiceEndpoint() to achive standard endpoi...
[mono.git] / web / rationale
index f8e6a1e3a42e75dde0123fd35420fd043d075079..91cd3c7af7bdcb93d193377f67d88553c551b374 100644 (file)
@@ -8,35 +8,37 @@
        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 on most
+       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 and
+       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://www.ximian.com/tech/bonobo.php3">Bonobo<a>, and
-       easy to use interfaces to Bonobo exist for C, Perl, Python,
+       href="http://developer.ximian.com/articles/whitepapers/bonobo">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 implementing an XML parser component and use it to
-       parse, create and walk an XML document would be inneficient
-       compared to a C API.
+       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.  
-
-       Depending who you ask, you will probably get a different
-       answer on what .NET is, as .NET is a branding formative that
+       user applications.  .NET is a branding formative that
        has been applied to:
 
        <ul>
 
        </ul>
 
-       From all the above, the one I am interested in is the new .NET
-       development platform. 
+       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
@@ -70,7 +70,7 @@
 
                * A comprehensive class library.  
 
-               * A new language, C#.  Very similar to Java.  C#
+               * A new language, C#.  Very similar to Java,  C#
                  allows programmers to use all the features available
                  on the .NET runtime.
 
 
 ** ECMA standards.
 
-       Microsoft together with HP and Intel have submitted the
+       Microsoft has submitted the
        specifications of C#, the runtime, the metadata and the
        other various bits of the .NET development platform to the
-       ECMA for standarization.  
+       <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>
 
 ** What makes up Mono?
 
-       There are various pieces that will make up Mono:
+       There are various pieces that make up Mono today:
 
        <ul>
                * A C# compiler.
 
-               * The Virtual Execution System: that will have the
+               * The Virtual Execution System: that has the
                  Just-in-Time compiler, garbage collector, loader,
                  threading engine.
 
-                 A byte code interpreter will be provided for quickly
+                 A byte code interpreter is 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.
+               * An implemenation of the .NET class libraries:
+                 Remoting, Reflection, Reflection.Emit, Xml, Xpath,
+                 Xslt, Xml Serialization, Web Services support. 
+
+               * Cross platform class libraries for data access:
+                 Postgress, MySQL, DB2, TDS, Sybase, Oracle, ODBC and
+                 Gnome's GDA.
+
+               * Unix class libraries: Mono.Posix
+
+               * Gnome-specific class libraries: The Gtk# family. 
+
+               * A code pre-compiler to generate native code ahead of
+                 time.
+
+               * Gtk# a toolkit to develop GNOME applications on Unix
+                 and Windows.
+
+               * An implementation of the Remoting infrastructure in
+                .NET
+       </ul>
+
+       Other work-in-progress components:
+
+       <ul>
+               * A VB.NET compiler and JScript compilers are in the works.
 
-               * Visual development tools. 
+               * Web services on the server side.
 
-               * A CIL GCC frontend.
+               * We are planning to include Remoting.CORBA as part of
+                 Mono standard distribution.
        </ul>
 
 ** Why use GNOME components?